// $ANTLR 3.3 Nov 30, 2010 12:50:56 e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g 2012-07-29 23:27:55

package org.bee.tl.core;
import org.bee.tl.core.compile.*;




import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;

public class BeeParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "VAR_DEFINE", "VAR_REFER", "ASSIGNMENT", "HOLDER", "TEXT_HOLDER", "FOR", "VAR_TEXT", "FM", "SLIST", "IF", "EXP", "COND_EXP", "FUNCTION", "TEXT_PROCESS", "ATTR_NAME", "VIRTUAL_ATTR_NAME", "MAP_LIST_INDEX", "BREAK", "CONTINUE", "RETURN", "NOT", "SWITCH", "CASE", "DEFAULT", "JSON", "JSONARRAY", "JSONMAP", "JSONKEYVALUE", "CLASS_STATIC_FUNCTION", "CLASS_FUNCTION", "CLASS_METHOD", "VARIABLE_VAR_REFER", "TEXT_VAR_REFER", "MISSING_VARIABLE_VAR_REFER", "FUNCTION_FULL_NAME", "SAFE_OUTPUT", "DIRECT_CALL", "NEGATOM", "LEFT_BRACE", "RIGHT_BRACE", "Identifier", "LEFT_TEXT_TOKEN", "RIGHT_TOKEN", "LEFT_TOKEN", "StringLiteral", "VAR", "OR", "AND", "EQUAL", "NOT_EQUAL", "LARGE", "LARGE_EQUAL", "LESS", "LESS_EQUAL", "ADD", "MINUS", "MULTIP", "DIV", "MOD", "BOOLEAN", "INT", "NULL", "DOUBLE", "ID_START", "Comment", "LineComment", "DoubleStringCharacter", "SingleStringCharacter", "EscapeSequence", "CharacterEscapeSequence", "HexEscapeSequence", "UnicodeEscapeSequence", "SingleEscapeCharacter", "NonEscapeCharacter", "EscapeCharacter", "DecimalDigit", "HexDigit", "DecimalLiteral", "HexIntegerLiteral", "NumericLiteral", "ExponentPart", "IdentifierStart", "IdentifierPart", "UnicodeLetter", "UnicodeDigit", "UnicodeConnectorPunctuation", "UnicodeCombiningMark", "WhiteSpace", "';'", "'return'", "'continue'", "'break'", "'('", "','", "')'", "'for'", "'in '", "'!'", "'if'", "'else'", "'!('", "'='", "'.'", "'.~'", "'['", "']'", "'@'", "'switch'", "'case'", "':'", "'default'"
    };
    public static final int EOF=-1;
    public static final int T__92=92;
    public static final int T__93=93;
    public static final int T__94=94;
    public static final int T__95=95;
    public static final int T__96=96;
    public static final int T__97=97;
    public static final int T__98=98;
    public static final int T__99=99;
    public static final int T__100=100;
    public static final int T__101=101;
    public static final int T__102=102;
    public static final int T__103=103;
    public static final int T__104=104;
    public static final int T__105=105;
    public static final int T__106=106;
    public static final int T__107=107;
    public static final int T__108=108;
    public static final int T__109=109;
    public static final int T__110=110;
    public static final int T__111=111;
    public static final int T__112=112;
    public static final int T__113=113;
    public static final int T__114=114;
    public static final int VAR_DEFINE=4;
    public static final int VAR_REFER=5;
    public static final int ASSIGNMENT=6;
    public static final int HOLDER=7;
    public static final int TEXT_HOLDER=8;
    public static final int FOR=9;
    public static final int VAR_TEXT=10;
    public static final int FM=11;
    public static final int SLIST=12;
    public static final int IF=13;
    public static final int EXP=14;
    public static final int COND_EXP=15;
    public static final int FUNCTION=16;
    public static final int TEXT_PROCESS=17;
    public static final int ATTR_NAME=18;
    public static final int VIRTUAL_ATTR_NAME=19;
    public static final int MAP_LIST_INDEX=20;
    public static final int BREAK=21;
    public static final int CONTINUE=22;
    public static final int RETURN=23;
    public static final int NOT=24;
    public static final int SWITCH=25;
    public static final int CASE=26;
    public static final int DEFAULT=27;
    public static final int JSON=28;
    public static final int JSONARRAY=29;
    public static final int JSONMAP=30;
    public static final int JSONKEYVALUE=31;
    public static final int CLASS_STATIC_FUNCTION=32;
    public static final int CLASS_FUNCTION=33;
    public static final int CLASS_METHOD=34;
    public static final int VARIABLE_VAR_REFER=35;
    public static final int TEXT_VAR_REFER=36;
    public static final int MISSING_VARIABLE_VAR_REFER=37;
    public static final int FUNCTION_FULL_NAME=38;
    public static final int SAFE_OUTPUT=39;
    public static final int DIRECT_CALL=40;
    public static final int NEGATOM=41;
    public static final int LEFT_BRACE=42;
    public static final int RIGHT_BRACE=43;
    public static final int Identifier=44;
    public static final int LEFT_TEXT_TOKEN=45;
    public static final int RIGHT_TOKEN=46;
    public static final int LEFT_TOKEN=47;
    public static final int StringLiteral=48;
    public static final int VAR=49;
    public static final int OR=50;
    public static final int AND=51;
    public static final int EQUAL=52;
    public static final int NOT_EQUAL=53;
    public static final int LARGE=54;
    public static final int LARGE_EQUAL=55;
    public static final int LESS=56;
    public static final int LESS_EQUAL=57;
    public static final int ADD=58;
    public static final int MINUS=59;
    public static final int MULTIP=60;
    public static final int DIV=61;
    public static final int MOD=62;
    public static final int BOOLEAN=63;
    public static final int INT=64;
    public static final int NULL=65;
    public static final int DOUBLE=66;
    public static final int ID_START=67;
    public static final int Comment=68;
    public static final int LineComment=69;
    public static final int DoubleStringCharacter=70;
    public static final int SingleStringCharacter=71;
    public static final int EscapeSequence=72;
    public static final int CharacterEscapeSequence=73;
    public static final int HexEscapeSequence=74;
    public static final int UnicodeEscapeSequence=75;
    public static final int SingleEscapeCharacter=76;
    public static final int NonEscapeCharacter=77;
    public static final int EscapeCharacter=78;
    public static final int DecimalDigit=79;
    public static final int HexDigit=80;
    public static final int DecimalLiteral=81;
    public static final int HexIntegerLiteral=82;
    public static final int NumericLiteral=83;
    public static final int ExponentPart=84;
    public static final int IdentifierStart=85;
    public static final int IdentifierPart=86;
    public static final int UnicodeLetter=87;
    public static final int UnicodeDigit=88;
    public static final int UnicodeConnectorPunctuation=89;
    public static final int UnicodeCombiningMark=90;
    public static final int WhiteSpace=91;

    // delegates
    // delegators


        public BeeParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public BeeParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
            this.state.ruleMemo = new HashMap[103+1];
             
             
        }
        
    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {
        this.adaptor = adaptor;
    }
    public TreeAdaptor getTreeAdaptor() {
        return adaptor;
    }

    public String[] getTokenNames() { return BeeParser.tokenNames; }
    public String getGrammarFileName() { return "e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g"; }


    boolean isStrictMVC = false;
    Template template = null;

    boolean openBackdoor = Boolean.parseBoolean(System.getProperty("BEETL_OPEN_BACKDOOR","true"));

    public void setStrictMVC(boolean isStrictMVC ){
    	this.isStrictMVC = isStrictMVC;
    }

    public void setTemplate(Template t){
    	this.template = t ;
    }

    public boolean isTextProcessFunction(TokenStream input){
    	StringBuilder sb = new StringBuilder();
    	int i=1;
    	while(true){
    	   Token t = input.LT(i++);
    	   if (t == null)
    				return false;
    	   if(t.getText().equals("(")){
    	   		break;
    	   }
    	   sb.append(t.getText());
    	}
    	
    	return template.containTag(sb.toString());
    }
    public void setNativeCall(boolean canNativeCall ){
    	this.openBackdoor = canNativeCall;
    }
    protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow)
    	throws RecognitionException
    {
    	throw new MismatchedTokenException(ttype, input);
    }
    public void emitErrorMessage(String msg) {
    	//	System.err.println(msg);
    	// do not display error ,instead of ErrorHndler
    }



    public static class prog_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "prog"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:124:1: prog : statements EOF ;
    public final BeeParser.prog_return prog() throws RecognitionException {
        BeeParser.prog_return retval = new BeeParser.prog_return();
        retval.start = input.LT(1);
        int prog_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token EOF2=null;
        BeeParser.statements_return statements1 = null;


        BeeCommonNodeTree EOF2_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:124:6: ( statements EOF )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:124:8: statements EOF
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_statements_in_prog285);
            statements1=statements();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, statements1.getTree());
            EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_prog287); if (state.failed) return retval;

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 1, prog_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "prog"

    public static class statements_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statements"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:125:1: statements : ( statement )+ ;
    public final BeeParser.statements_return statements() throws RecognitionException {
        BeeParser.statements_return retval = new BeeParser.statements_return();
        retval.start = input.LT(1);
        int statements_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        BeeParser.statement_return statement3 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:125:12: ( ( statement )+ )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:125:13: ( statement )+
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:125:13: ( statement )+
            int cnt1=0;
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==LEFT_BRACE||(LA1_0>=Identifier && LA1_0<=LEFT_TEXT_TOKEN)||LA1_0==LEFT_TOKEN||LA1_0==VAR||(LA1_0>=93 && LA1_0<=95)||LA1_0==99||LA1_0==102||(LA1_0>=110 && LA1_0<=111)) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:0:0: statement
            	    {
            	    pushFollow(FOLLOW_statement_in_statements295);
            	    statement3=statement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement3.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt1 >= 1 ) break loop1;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(1, input);
                        throw eee;
                }
                cnt1++;
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 2, statements_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "statements"

    public static class statement_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statement"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:126:1: statement : ( constantsTextStatment | varDefine ';' | assignMent ';' | textStatment | ifStatment | forStatment | statmentBlock | messFunction | continueStatment ';' | breakStatment ';' | returnStatment ';' | switchStatment | nativeMethod[true] ';' );
    public final BeeParser.statement_return statement() throws RecognitionException {
        BeeParser.statement_return retval = new BeeParser.statement_return();
        retval.start = input.LT(1);
        int statement_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token char_literal6=null;
        Token char_literal8=null;
        Token char_literal15=null;
        Token char_literal17=null;
        Token char_literal19=null;
        Token char_literal22=null;
        BeeParser.constantsTextStatment_return constantsTextStatment4 = null;

        BeeParser.varDefine_return varDefine5 = null;

        BeeParser.assignMent_return assignMent7 = null;

        BeeParser.textStatment_return textStatment9 = null;

        BeeParser.ifStatment_return ifStatment10 = null;

        BeeParser.forStatment_return forStatment11 = null;

        BeeParser.statmentBlock_return statmentBlock12 = null;

        BeeParser.messFunction_return messFunction13 = null;

        BeeParser.continueStatment_return continueStatment14 = null;

        BeeParser.breakStatment_return breakStatment16 = null;

        BeeParser.returnStatment_return returnStatment18 = null;

        BeeParser.switchStatment_return switchStatment20 = null;

        BeeParser.nativeMethod_return nativeMethod21 = null;


        BeeCommonNodeTree char_literal6_tree=null;
        BeeCommonNodeTree char_literal8_tree=null;
        BeeCommonNodeTree char_literal15_tree=null;
        BeeCommonNodeTree char_literal17_tree=null;
        BeeCommonNodeTree char_literal19_tree=null;
        BeeCommonNodeTree char_literal22_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:127:2: ( constantsTextStatment | varDefine ';' | assignMent ';' | textStatment | ifStatment | forStatment | statmentBlock | messFunction | continueStatment ';' | breakStatment ';' | returnStatment ';' | switchStatment | nativeMethod[true] ';' )
            int alt2=13;
            alt2 = dfa2.predict(input);
            switch (alt2) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:127:4: constantsTextStatment
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_constantsTextStatment_in_statement304);
                    constantsTextStatment4=constantsTextStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, constantsTextStatment4.getTree());

                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:128:6: varDefine ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_varDefine_in_statement311);
                    varDefine5=varDefine();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, varDefine5.getTree());
                    char_literal6=(Token)match(input,92,FOLLOW_92_in_statement313); if (state.failed) return retval;

                    }
                    break;
                case 3 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:129:4: assignMent ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_assignMent_in_statement319);
                    assignMent7=assignMent();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignMent7.getTree());
                    char_literal8=(Token)match(input,92,FOLLOW_92_in_statement321); if (state.failed) return retval;

                    }
                    break;
                case 4 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:130:4: textStatment
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_textStatment_in_statement327);
                    textStatment9=textStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, textStatment9.getTree());

                    }
                    break;
                case 5 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:131:4: ifStatment
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_ifStatment_in_statement332);
                    ifStatment10=ifStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, ifStatment10.getTree());

                    }
                    break;
                case 6 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:132:4: forStatment
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_forStatment_in_statement337);
                    forStatment11=forStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forStatment11.getTree());

                    }
                    break;
                case 7 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:133:4: statmentBlock
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_statmentBlock_in_statement342);
                    statmentBlock12=statmentBlock();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statmentBlock12.getTree());

                    }
                    break;
                case 8 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:134:4: messFunction
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_messFunction_in_statement347);
                    messFunction13=messFunction();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, messFunction13.getTree());

                    }
                    break;
                case 9 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:135:4: continueStatment ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_continueStatment_in_statement352);
                    continueStatment14=continueStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, continueStatment14.getTree());
                    char_literal15=(Token)match(input,92,FOLLOW_92_in_statement354); if (state.failed) return retval;

                    }
                    break;
                case 10 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:136:4: breakStatment ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_breakStatment_in_statement360);
                    breakStatment16=breakStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, breakStatment16.getTree());
                    char_literal17=(Token)match(input,92,FOLLOW_92_in_statement362); if (state.failed) return retval;

                    }
                    break;
                case 11 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:137:4: returnStatment ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_returnStatment_in_statement368);
                    returnStatment18=returnStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, returnStatment18.getTree());
                    char_literal19=(Token)match(input,92,FOLLOW_92_in_statement370); if (state.failed) return retval;

                    }
                    break;
                case 12 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:138:4: switchStatment
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_switchStatment_in_statement376);
                    switchStatment20=switchStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, switchStatment20.getTree());

                    }
                    break;
                case 13 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:139:4: nativeMethod[true] ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_nativeMethod_in_statement381);
                    nativeMethod21=nativeMethod(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nativeMethod21.getTree());
                    char_literal22=(Token)match(input,92,FOLLOW_92_in_statement384); if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 3, statement_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public static class returnStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "returnStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:145:1: returnStatment : 'return' -> ^( RETURN ) ;
    public final BeeParser.returnStatment_return returnStatment() throws RecognitionException {
        BeeParser.returnStatment_return retval = new BeeParser.returnStatment_return();
        retval.start = input.LT(1);
        int returnStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token string_literal23=null;

        BeeCommonNodeTree string_literal23_tree=null;
        RewriteRuleTokenStream stream_93=new RewriteRuleTokenStream(adaptor,"token 93");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:146:2: ( 'return' -> ^( RETURN ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:146:4: 'return'
            {
            string_literal23=(Token)match(input,93,FOLLOW_93_in_returnStatment401); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_93.add(string_literal23);



            // AST REWRITE
            // elements: 
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 146:13: -> ^( RETURN )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:146:16: ^( RETURN )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(RETURN, "RETURN"), root_1);

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 4, returnStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "returnStatment"

    public static class continueStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "continueStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:147:1: continueStatment : 'continue' -> ^( CONTINUE ) ;
    public final BeeParser.continueStatment_return continueStatment() throws RecognitionException {
        BeeParser.continueStatment_return retval = new BeeParser.continueStatment_return();
        retval.start = input.LT(1);
        int continueStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token string_literal24=null;

        BeeCommonNodeTree string_literal24_tree=null;
        RewriteRuleTokenStream stream_94=new RewriteRuleTokenStream(adaptor,"token 94");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:147:17: ( 'continue' -> ^( CONTINUE ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:147:19: 'continue'
            {
            string_literal24=(Token)match(input,94,FOLLOW_94_in_continueStatment414); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_94.add(string_literal24);



            // AST REWRITE
            // elements: 
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 147:30: -> ^( CONTINUE )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:147:33: ^( CONTINUE )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(CONTINUE, "CONTINUE"), root_1);

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 5, continueStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "continueStatment"

    public static class breakStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "breakStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:148:1: breakStatment : 'break' -> ^( BREAK ) ;
    public final BeeParser.breakStatment_return breakStatment() throws RecognitionException {
        BeeParser.breakStatment_return retval = new BeeParser.breakStatment_return();
        retval.start = input.LT(1);
        int breakStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token string_literal25=null;

        BeeCommonNodeTree string_literal25_tree=null;
        RewriteRuleTokenStream stream_95=new RewriteRuleTokenStream(adaptor,"token 95");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:148:15: ( 'break' -> ^( BREAK ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:148:17: 'break'
            {
            string_literal25=(Token)match(input,95,FOLLOW_95_in_breakStatment428); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_95.add(string_literal25);



            // AST REWRITE
            // elements: 
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 148:25: -> ^( BREAK )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:148:28: ^( BREAK )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(BREAK, "BREAK"), root_1);

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 6, breakStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "breakStatment"

    public static class messFunction_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "messFunction"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:150:1: messFunction options {backtrack=false; } : ({...}? textProcessFunction | functionCall[true] ';' );
    public final BeeParser.messFunction_return messFunction() throws RecognitionException {
        BeeParser.messFunction_return retval = new BeeParser.messFunction_return();
        retval.start = input.LT(1);
        int messFunction_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token char_literal28=null;
        BeeParser.textProcessFunction_return textProcessFunction26 = null;

        BeeParser.functionCall_return functionCall27 = null;


        BeeCommonNodeTree char_literal28_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:153:2: ({...}? textProcessFunction | functionCall[true] ';' )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==Identifier) ) {
                int LA3_1 = input.LA(2);

                if ( ((isTextProcessFunction(input))) ) {
                    alt3=1;
                }
                else if ( (true) ) {
                    alt3=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 3, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:153:4: {...}? textProcessFunction
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    if ( !((isTextProcessFunction(input))) ) {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        throw new FailedPredicateException(input, "messFunction", "isTextProcessFunction(input)");
                    }
                    pushFollow(FOLLOW_textProcessFunction_in_messFunction455);
                    textProcessFunction26=textProcessFunction();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, textProcessFunction26.getTree());

                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:154:6: functionCall[true] ';'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_functionCall_in_messFunction462);
                    functionCall27=functionCall(true);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionCall27.getTree());
                    char_literal28=(Token)match(input,92,FOLLOW_92_in_messFunction465); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal28_tree = (BeeCommonNodeTree)adaptor.create(char_literal28);
                    adaptor.addChild(root_0, char_literal28_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 7, messFunction_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "messFunction"

    public static class textProcessFunction_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "textProcessFunction"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:156:1: textProcessFunction : functionFullName a= '(' ( exp ( ',' exp )* )? ')' statmentBlock -> ^( TEXT_PROCESS[$a] functionFullName statmentBlock ( exp )* ) ;
    public final BeeParser.textProcessFunction_return textProcessFunction() throws RecognitionException {
        BeeParser.textProcessFunction_return retval = new BeeParser.textProcessFunction_return();
        retval.start = input.LT(1);
        int textProcessFunction_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal31=null;
        Token char_literal33=null;
        BeeParser.functionFullName_return functionFullName29 = null;

        BeeParser.exp_return exp30 = null;

        BeeParser.exp_return exp32 = null;

        BeeParser.statmentBlock_return statmentBlock34 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal31_tree=null;
        BeeCommonNodeTree char_literal33_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        RewriteRuleSubtreeStream stream_functionFullName=new RewriteRuleSubtreeStream(adaptor,"rule functionFullName");
        RewriteRuleSubtreeStream stream_statmentBlock=new RewriteRuleSubtreeStream(adaptor,"rule statmentBlock");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:2: ( functionFullName a= '(' ( exp ( ',' exp )* )? ')' statmentBlock -> ^( TEXT_PROCESS[$a] functionFullName statmentBlock ( exp )* ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:4: functionFullName a= '(' ( exp ( ',' exp )* )? ')' statmentBlock
            {
            pushFollow(FOLLOW_functionFullName_in_textProcessFunction476);
            functionFullName29=functionFullName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_functionFullName.add(functionFullName29.getTree());
            a=(Token)match(input,96,FOLLOW_96_in_textProcessFunction480); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(a);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:27: ( exp ( ',' exp )* )?
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==LEFT_BRACE||LA5_0==Identifier||LA5_0==StringLiteral||(LA5_0>=ADD && LA5_0<=MINUS)||(LA5_0>=BOOLEAN && LA5_0<=DOUBLE)||LA5_0==96||LA5_0==101||LA5_0==108||LA5_0==110) ) {
                alt5=1;
            }
            switch (alt5) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:28: exp ( ',' exp )*
                    {
                    pushFollow(FOLLOW_exp_in_textProcessFunction483);
                    exp30=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_exp.add(exp30.getTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:32: ( ',' exp )*
                    loop4:
                    do {
                        int alt4=2;
                        int LA4_0 = input.LA(1);

                        if ( (LA4_0==97) ) {
                            alt4=1;
                        }


                        switch (alt4) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:33: ',' exp
                    	    {
                    	    char_literal31=(Token)match(input,97,FOLLOW_97_in_textProcessFunction486); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_97.add(char_literal31);

                    	    pushFollow(FOLLOW_exp_in_textProcessFunction488);
                    	    exp32=exp();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_exp.add(exp32.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop4;
                        }
                    } while (true);


                    }
                    break;

            }

            char_literal33=(Token)match(input,98,FOLLOW_98_in_textProcessFunction494); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal33);

            pushFollow(FOLLOW_statmentBlock_in_textProcessFunction496);
            statmentBlock34=statmentBlock();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_statmentBlock.add(statmentBlock34.getTree());


            // AST REWRITE
            // elements: functionFullName, statmentBlock, exp
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 158:63: -> ^( TEXT_PROCESS[$a] functionFullName statmentBlock ( exp )* )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:66: ^( TEXT_PROCESS[$a] functionFullName statmentBlock ( exp )* )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(TEXT_PROCESS, a), root_1);

                adaptor.addChild(root_1, stream_functionFullName.nextTree());
                adaptor.addChild(root_1, stream_statmentBlock.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:158:116: ( exp )*
                while ( stream_exp.hasNext() ) {
                    adaptor.addChild(root_1, stream_exp.nextTree());

                }
                stream_exp.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 8, textProcessFunction_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "textProcessFunction"

    public static class functionCall_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "functionCall"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:161:1: functionCall[boolean statmentCall] : functionFullName a= '(' ( exp ( ',' exp )* )? ')' -> {statmentCall}? ^( DIRECT_CALL ^( FUNCTION[$a] functionFullName ( exp )* ) ) -> ^( FUNCTION[$a] functionFullName ( exp )* ) ;
    public final BeeParser.functionCall_return functionCall(boolean statmentCall) throws RecognitionException {
        BeeParser.functionCall_return retval = new BeeParser.functionCall_return();
        retval.start = input.LT(1);
        int functionCall_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal37=null;
        Token char_literal39=null;
        BeeParser.functionFullName_return functionFullName35 = null;

        BeeParser.exp_return exp36 = null;

        BeeParser.exp_return exp38 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal37_tree=null;
        BeeCommonNodeTree char_literal39_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        RewriteRuleSubtreeStream stream_functionFullName=new RewriteRuleSubtreeStream(adaptor,"rule functionFullName");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:2: ( functionFullName a= '(' ( exp ( ',' exp )* )? ')' -> {statmentCall}? ^( DIRECT_CALL ^( FUNCTION[$a] functionFullName ( exp )* ) ) -> ^( FUNCTION[$a] functionFullName ( exp )* ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:3: functionFullName a= '(' ( exp ( ',' exp )* )? ')'
            {
            pushFollow(FOLLOW_functionFullName_in_functionCall531);
            functionFullName35=functionFullName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_functionFullName.add(functionFullName35.getTree());
            a=(Token)match(input,96,FOLLOW_96_in_functionCall535); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(a);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:26: ( exp ( ',' exp )* )?
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==LEFT_BRACE||LA7_0==Identifier||LA7_0==StringLiteral||(LA7_0>=ADD && LA7_0<=MINUS)||(LA7_0>=BOOLEAN && LA7_0<=DOUBLE)||LA7_0==96||LA7_0==101||LA7_0==108||LA7_0==110) ) {
                alt7=1;
            }
            switch (alt7) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:27: exp ( ',' exp )*
                    {
                    pushFollow(FOLLOW_exp_in_functionCall538);
                    exp36=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_exp.add(exp36.getTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:31: ( ',' exp )*
                    loop6:
                    do {
                        int alt6=2;
                        int LA6_0 = input.LA(1);

                        if ( (LA6_0==97) ) {
                            alt6=1;
                        }


                        switch (alt6) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:167:32: ',' exp
                    	    {
                    	    char_literal37=(Token)match(input,97,FOLLOW_97_in_functionCall541); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_97.add(char_literal37);

                    	    pushFollow(FOLLOW_exp_in_functionCall543);
                    	    exp38=exp();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_exp.add(exp38.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);


                    }
                    break;

            }

            char_literal39=(Token)match(input,98,FOLLOW_98_in_functionCall549); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal39);



            // AST REWRITE
            // elements: exp, functionFullName, functionFullName, exp
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 168:3: -> {statmentCall}? ^( DIRECT_CALL ^( FUNCTION[$a] functionFullName ( exp )* ) )
            if (statmentCall) {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:168:22: ^( DIRECT_CALL ^( FUNCTION[$a] functionFullName ( exp )* ) )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(DIRECT_CALL, "DIRECT_CALL"), root_1);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:168:36: ^( FUNCTION[$a] functionFullName ( exp )* )
                {
                BeeCommonNodeTree root_2 = (BeeCommonNodeTree)adaptor.nil();
                root_2 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(FUNCTION, a), root_2);

                adaptor.addChild(root_2, stream_functionFullName.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:168:68: ( exp )*
                while ( stream_exp.hasNext() ) {
                    adaptor.addChild(root_2, stream_exp.nextTree());

                }
                stream_exp.reset();

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 169:3: -> ^( FUNCTION[$a] functionFullName ( exp )* )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:169:6: ^( FUNCTION[$a] functionFullName ( exp )* )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(FUNCTION, a), root_1);

                adaptor.addChild(root_1, stream_functionFullName.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:169:38: ( exp )*
                while ( stream_exp.hasNext() ) {
                    adaptor.addChild(root_1, stream_exp.nextTree());

                }
                stream_exp.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
            if ( state.backtracking==0 ) {

              		if(isStrictMVC){
              			throw new MVCStrictException(((Token)retval.start));			
              		}
              	
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 9, functionCall_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "functionCall"

    public static class statmentBlock_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "statmentBlock"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:173:1: statmentBlock : LEFT_BRACE ( statements )? RIGHT_BRACE -> ^( SLIST ( statements )? ) ;
    public final BeeParser.statmentBlock_return statmentBlock() throws RecognitionException {
        BeeParser.statmentBlock_return retval = new BeeParser.statmentBlock_return();
        retval.start = input.LT(1);
        int statmentBlock_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token LEFT_BRACE40=null;
        Token RIGHT_BRACE42=null;
        BeeParser.statements_return statements41 = null;


        BeeCommonNodeTree LEFT_BRACE40_tree=null;
        BeeCommonNodeTree RIGHT_BRACE42_tree=null;
        RewriteRuleTokenStream stream_RIGHT_BRACE=new RewriteRuleTokenStream(adaptor,"token RIGHT_BRACE");
        RewriteRuleTokenStream stream_LEFT_BRACE=new RewriteRuleTokenStream(adaptor,"token LEFT_BRACE");
        RewriteRuleSubtreeStream stream_statements=new RewriteRuleSubtreeStream(adaptor,"rule statements");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:174:2: ( LEFT_BRACE ( statements )? RIGHT_BRACE -> ^( SLIST ( statements )? ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:174:4: LEFT_BRACE ( statements )? RIGHT_BRACE
            {
            LEFT_BRACE40=(Token)match(input,LEFT_BRACE,FOLLOW_LEFT_BRACE_in_statmentBlock598); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LEFT_BRACE.add(LEFT_BRACE40);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:174:15: ( statements )?
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==LEFT_BRACE||(LA8_0>=Identifier && LA8_0<=LEFT_TEXT_TOKEN)||LA8_0==LEFT_TOKEN||LA8_0==VAR||(LA8_0>=93 && LA8_0<=95)||LA8_0==99||LA8_0==102||(LA8_0>=110 && LA8_0<=111)) ) {
                alt8=1;
            }
            switch (alt8) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:0:0: statements
                    {
                    pushFollow(FOLLOW_statements_in_statmentBlock600);
                    statements41=statements();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_statements.add(statements41.getTree());

                    }
                    break;

            }

            RIGHT_BRACE42=(Token)match(input,RIGHT_BRACE,FOLLOW_RIGHT_BRACE_in_statmentBlock603); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RIGHT_BRACE.add(RIGHT_BRACE42);



            // AST REWRITE
            // elements: statements
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 174:39: -> ^( SLIST ( statements )? )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:174:42: ^( SLIST ( statements )? )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(SLIST, "SLIST"), root_1);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:174:50: ( statements )?
                if ( stream_statements.hasNext() ) {
                    adaptor.addChild(root_1, stream_statements.nextTree());

                }
                stream_statements.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 10, statmentBlock_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "statmentBlock"

    public static class forStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "forStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:175:1: forStatment : 'for' '(' a= Identifier 'in ' aaa= varRef (b= '!' )? ')' statmentBlock -> ^( FOR $a $aaa statmentBlock ( $b)? ) ;
    public final BeeParser.forStatment_return forStatment() throws RecognitionException {
        BeeParser.forStatment_return retval = new BeeParser.forStatment_return();
        retval.start = input.LT(1);
        int forStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token b=null;
        Token string_literal43=null;
        Token char_literal44=null;
        Token string_literal45=null;
        Token char_literal46=null;
        BeeParser.varRef_return aaa = null;

        BeeParser.statmentBlock_return statmentBlock47 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree b_tree=null;
        BeeCommonNodeTree string_literal43_tree=null;
        BeeCommonNodeTree char_literal44_tree=null;
        BeeCommonNodeTree string_literal45_tree=null;
        BeeCommonNodeTree char_literal46_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleTokenStream stream_99=new RewriteRuleTokenStream(adaptor,"token 99");
        RewriteRuleTokenStream stream_101=new RewriteRuleTokenStream(adaptor,"token 101");
        RewriteRuleTokenStream stream_100=new RewriteRuleTokenStream(adaptor,"token 100");
        RewriteRuleSubtreeStream stream_varRef=new RewriteRuleSubtreeStream(adaptor,"rule varRef");
        RewriteRuleSubtreeStream stream_statmentBlock=new RewriteRuleSubtreeStream(adaptor,"rule statmentBlock");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:2: ( 'for' '(' a= Identifier 'in ' aaa= varRef (b= '!' )? ')' statmentBlock -> ^( FOR $a $aaa statmentBlock ( $b)? ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:4: 'for' '(' a= Identifier 'in ' aaa= varRef (b= '!' )? ')' statmentBlock
            {
            string_literal43=(Token)match(input,99,FOLLOW_99_in_forStatment620); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_99.add(string_literal43);

            char_literal44=(Token)match(input,96,FOLLOW_96_in_forStatment622); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(char_literal44);

            a=(Token)match(input,Identifier,FOLLOW_Identifier_in_forStatment626); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(a);

            string_literal45=(Token)match(input,100,FOLLOW_100_in_forStatment628); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_100.add(string_literal45);

            pushFollow(FOLLOW_varRef_in_forStatment632);
            aaa=varRef();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_varRef.add(aaa.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:44: (b= '!' )?
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==101) ) {
                alt9=1;
            }
            switch (alt9) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:45: b= '!'
                    {
                    b=(Token)match(input,101,FOLLOW_101_in_forStatment637); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_101.add(b);


                    }
                    break;

            }

            char_literal46=(Token)match(input,98,FOLLOW_98_in_forStatment641); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal46);

            pushFollow(FOLLOW_statmentBlock_in_forStatment646);
            statmentBlock47=statmentBlock();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_statmentBlock.add(statmentBlock47.getTree());


            // AST REWRITE
            // elements: b, aaa, statmentBlock, a
            // token labels: b, a
            // rule labels: retval, aaa
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleTokenStream stream_b=new RewriteRuleTokenStream(adaptor,"token b",b);
            RewriteRuleTokenStream stream_a=new RewriteRuleTokenStream(adaptor,"token a",a);
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_aaa=new RewriteRuleSubtreeStream(adaptor,"rule aaa",aaa!=null?aaa.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 176:77: -> ^( FOR $a $aaa statmentBlock ( $b)? )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:80: ^( FOR $a $aaa statmentBlock ( $b)? )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(FOR, "FOR"), root_1);

                adaptor.addChild(root_1, stream_a.nextNode());
                adaptor.addChild(root_1, stream_aaa.nextTree());
                adaptor.addChild(root_1, stream_statmentBlock.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:176:109: ( $b)?
                if ( stream_b.hasNext() ) {
                    adaptor.addChild(root_1, stream_b.nextNode());

                }
                stream_b.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 11, forStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "forStatment"

    public static class ifStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "ifStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:177:1: ifStatment : 'if' '(' condExp ')' l= statement ( 'else' n= statement )? -> ^( IF condExp $l ( $n)? ) ;
    public final BeeParser.ifStatment_return ifStatment() throws RecognitionException {
        BeeParser.ifStatment_return retval = new BeeParser.ifStatment_return();
        retval.start = input.LT(1);
        int ifStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token string_literal48=null;
        Token char_literal49=null;
        Token char_literal51=null;
        Token string_literal52=null;
        BeeParser.statement_return l = null;

        BeeParser.statement_return n = null;

        BeeParser.condExp_return condExp50 = null;


        BeeCommonNodeTree string_literal48_tree=null;
        BeeCommonNodeTree char_literal49_tree=null;
        BeeCommonNodeTree char_literal51_tree=null;
        BeeCommonNodeTree string_literal52_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleTokenStream stream_103=new RewriteRuleTokenStream(adaptor,"token 103");
        RewriteRuleTokenStream stream_102=new RewriteRuleTokenStream(adaptor,"token 102");
        RewriteRuleSubtreeStream stream_statement=new RewriteRuleSubtreeStream(adaptor,"rule statement");
        RewriteRuleSubtreeStream stream_condExp=new RewriteRuleSubtreeStream(adaptor,"rule condExp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:2: ( 'if' '(' condExp ')' l= statement ( 'else' n= statement )? -> ^( IF condExp $l ( $n)? ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:4: 'if' '(' condExp ')' l= statement ( 'else' n= statement )?
            {
            string_literal48=(Token)match(input,102,FOLLOW_102_in_ifStatment678); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_102.add(string_literal48);

            char_literal49=(Token)match(input,96,FOLLOW_96_in_ifStatment680); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(char_literal49);

            pushFollow(FOLLOW_condExp_in_ifStatment682);
            condExp50=condExp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_condExp.add(condExp50.getTree());
            char_literal51=(Token)match(input,98,FOLLOW_98_in_ifStatment684); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal51);

            pushFollow(FOLLOW_statement_in_ifStatment688);
            l=statement();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_statement.add(l.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:37: ( 'else' n= statement )?
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==103) ) {
                int LA10_1 = input.LA(2);

                if ( (synpred20_Bee()) ) {
                    alt10=1;
                }
            }
            switch (alt10) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:38: 'else' n= statement
                    {
                    string_literal52=(Token)match(input,103,FOLLOW_103_in_ifStatment691); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_103.add(string_literal52);

                    pushFollow(FOLLOW_statement_in_ifStatment695);
                    n=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_statement.add(n.getTree());

                    }
                    break;

            }



            // AST REWRITE
            // elements: n, l, condExp
            // token labels: 
            // rule labels: retval, n, l
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_n=new RewriteRuleSubtreeStream(adaptor,"rule n",n!=null?n.tree:null);
            RewriteRuleSubtreeStream stream_l=new RewriteRuleSubtreeStream(adaptor,"rule l",l!=null?l.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 178:61: -> ^( IF condExp $l ( $n)? )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:63: ^( IF condExp $l ( $n)? )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(IF, "IF"), root_1);

                adaptor.addChild(root_1, stream_condExp.nextTree());
                adaptor.addChild(root_1, stream_l.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:79: ( $n)?
                if ( stream_n.hasNext() ) {
                    adaptor.addChild(root_1, stream_n.nextTree());

                }
                stream_n.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 12, ifStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "ifStatment"

    public static class constantsTextStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "constantsTextStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:180:1: constantsTextStatment : LEFT_TEXT_TOKEN Identifier RIGHT_TOKEN -> ^( TEXT_HOLDER Identifier ) ;
    public final BeeParser.constantsTextStatment_return constantsTextStatment() throws RecognitionException {
        BeeParser.constantsTextStatment_return retval = new BeeParser.constantsTextStatment_return();
        retval.start = input.LT(1);
        int constantsTextStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token LEFT_TEXT_TOKEN53=null;
        Token Identifier54=null;
        Token RIGHT_TOKEN55=null;

        BeeCommonNodeTree LEFT_TEXT_TOKEN53_tree=null;
        BeeCommonNodeTree Identifier54_tree=null;
        BeeCommonNodeTree RIGHT_TOKEN55_tree=null;
        RewriteRuleTokenStream stream_LEFT_TEXT_TOKEN=new RewriteRuleTokenStream(adaptor,"token LEFT_TEXT_TOKEN");
        RewriteRuleTokenStream stream_RIGHT_TOKEN=new RewriteRuleTokenStream(adaptor,"token RIGHT_TOKEN");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:181:2: ( LEFT_TEXT_TOKEN Identifier RIGHT_TOKEN -> ^( TEXT_HOLDER Identifier ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:181:4: LEFT_TEXT_TOKEN Identifier RIGHT_TOKEN
            {
            LEFT_TEXT_TOKEN53=(Token)match(input,LEFT_TEXT_TOKEN,FOLLOW_LEFT_TEXT_TOKEN_in_constantsTextStatment725); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LEFT_TEXT_TOKEN.add(LEFT_TEXT_TOKEN53);

            Identifier54=(Token)match(input,Identifier,FOLLOW_Identifier_in_constantsTextStatment728); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(Identifier54);

            RIGHT_TOKEN55=(Token)match(input,RIGHT_TOKEN,FOLLOW_RIGHT_TOKEN_in_constantsTextStatment730); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RIGHT_TOKEN.add(RIGHT_TOKEN55);



            // AST REWRITE
            // elements: Identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 181:46: -> ^( TEXT_HOLDER Identifier )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:181:48: ^( TEXT_HOLDER Identifier )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(TEXT_HOLDER, "TEXT_HOLDER"), root_1);

                adaptor.addChild(root_1, stream_Identifier.nextNode());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 13, constantsTextStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "constantsTextStatment"

    public static class textStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "textStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:183:1: textStatment : ( LEFT_TOKEN textVar RIGHT_TOKEN -> ^( HOLDER textVar ) | LEFT_TOKEN '!(' textVar ')' RIGHT_TOKEN -> ^( HOLDER textVar SAFE_OUTPUT ) );
    public final BeeParser.textStatment_return textStatment() throws RecognitionException {
        BeeParser.textStatment_return retval = new BeeParser.textStatment_return();
        retval.start = input.LT(1);
        int textStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token LEFT_TOKEN56=null;
        Token RIGHT_TOKEN58=null;
        Token LEFT_TOKEN59=null;
        Token string_literal60=null;
        Token char_literal62=null;
        Token RIGHT_TOKEN63=null;
        BeeParser.textVar_return textVar57 = null;

        BeeParser.textVar_return textVar61 = null;


        BeeCommonNodeTree LEFT_TOKEN56_tree=null;
        BeeCommonNodeTree RIGHT_TOKEN58_tree=null;
        BeeCommonNodeTree LEFT_TOKEN59_tree=null;
        BeeCommonNodeTree string_literal60_tree=null;
        BeeCommonNodeTree char_literal62_tree=null;
        BeeCommonNodeTree RIGHT_TOKEN63_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_LEFT_TOKEN=new RewriteRuleTokenStream(adaptor,"token LEFT_TOKEN");
        RewriteRuleTokenStream stream_RIGHT_TOKEN=new RewriteRuleTokenStream(adaptor,"token RIGHT_TOKEN");
        RewriteRuleTokenStream stream_104=new RewriteRuleTokenStream(adaptor,"token 104");
        RewriteRuleSubtreeStream stream_textVar=new RewriteRuleSubtreeStream(adaptor,"rule textVar");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:184:2: ( LEFT_TOKEN textVar RIGHT_TOKEN -> ^( HOLDER textVar ) | LEFT_TOKEN '!(' textVar ')' RIGHT_TOKEN -> ^( HOLDER textVar SAFE_OUTPUT ) )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==LEFT_TOKEN) ) {
                int LA11_1 = input.LA(2);

                if ( (LA11_1==104) ) {
                    alt11=2;
                }
                else if ( (LA11_1==LEFT_BRACE||LA11_1==Identifier||LA11_1==StringLiteral||(LA11_1>=ADD && LA11_1<=MINUS)||(LA11_1>=BOOLEAN && LA11_1<=DOUBLE)||LA11_1==96||LA11_1==101||LA11_1==108||LA11_1==110) ) {
                    alt11=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 11, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:185:6: LEFT_TOKEN textVar RIGHT_TOKEN
                    {
                    LEFT_TOKEN56=(Token)match(input,LEFT_TOKEN,FOLLOW_LEFT_TOKEN_in_textStatment760); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LEFT_TOKEN.add(LEFT_TOKEN56);

                    pushFollow(FOLLOW_textVar_in_textStatment762);
                    textVar57=textVar();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_textVar.add(textVar57.getTree());
                    RIGHT_TOKEN58=(Token)match(input,RIGHT_TOKEN,FOLLOW_RIGHT_TOKEN_in_textStatment764); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_RIGHT_TOKEN.add(RIGHT_TOKEN58);



                    // AST REWRITE
                    // elements: textVar
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 185:37: -> ^( HOLDER textVar )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:185:40: ^( HOLDER textVar )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(HOLDER, "HOLDER"), root_1);

                        adaptor.addChild(root_1, stream_textVar.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:186:4: LEFT_TOKEN '!(' textVar ')' RIGHT_TOKEN
                    {
                    LEFT_TOKEN59=(Token)match(input,LEFT_TOKEN,FOLLOW_LEFT_TOKEN_in_textStatment777); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LEFT_TOKEN.add(LEFT_TOKEN59);

                    string_literal60=(Token)match(input,104,FOLLOW_104_in_textStatment779); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_104.add(string_literal60);

                    pushFollow(FOLLOW_textVar_in_textStatment781);
                    textVar61=textVar();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_textVar.add(textVar61.getTree());
                    char_literal62=(Token)match(input,98,FOLLOW_98_in_textStatment783); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_98.add(char_literal62);

                    RIGHT_TOKEN63=(Token)match(input,RIGHT_TOKEN,FOLLOW_RIGHT_TOKEN_in_textStatment784); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_RIGHT_TOKEN.add(RIGHT_TOKEN63);



                    // AST REWRITE
                    // elements: textVar
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 186:43: -> ^( HOLDER textVar SAFE_OUTPUT )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:186:46: ^( HOLDER textVar SAFE_OUTPUT )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(HOLDER, "HOLDER"), root_1);

                        adaptor.addChild(root_1, stream_textVar.nextTree());
                        adaptor.addChild(root_1, (BeeCommonNodeTree)adaptor.create(SAFE_OUTPUT, "SAFE_OUTPUT"));

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 14, textStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "textStatment"

    public static class textVar_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "textVar"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:1: textVar : b= exp ( ',' fm= functionFullName ( '=' StringLiteral )? )* -> ^( VAR_TEXT $b ( ^( FM $fm ( StringLiteral )? ) )* ) ;
    public final BeeParser.textVar_return textVar() throws RecognitionException {
        BeeParser.textVar_return retval = new BeeParser.textVar_return();
        retval.start = input.LT(1);
        int textVar_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token char_literal64=null;
        Token char_literal65=null;
        Token StringLiteral66=null;
        BeeParser.exp_return b = null;

        BeeParser.functionFullName_return fm = null;


        BeeCommonNodeTree char_literal64_tree=null;
        BeeCommonNodeTree char_literal65_tree=null;
        BeeCommonNodeTree StringLiteral66_tree=null;
        RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_105=new RewriteRuleTokenStream(adaptor,"token 105");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        RewriteRuleSubtreeStream stream_functionFullName=new RewriteRuleSubtreeStream(adaptor,"rule functionFullName");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:9: (b= exp ( ',' fm= functionFullName ( '=' StringLiteral )? )* -> ^( VAR_TEXT $b ( ^( FM $fm ( StringLiteral )? ) )* ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:11: b= exp ( ',' fm= functionFullName ( '=' StringLiteral )? )*
            {
            pushFollow(FOLLOW_exp_in_textVar803);
            b=exp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_exp.add(b.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:17: ( ',' fm= functionFullName ( '=' StringLiteral )? )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==97) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:18: ',' fm= functionFullName ( '=' StringLiteral )?
            	    {
            	    char_literal64=(Token)match(input,97,FOLLOW_97_in_textVar806); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_97.add(char_literal64);

            	    pushFollow(FOLLOW_functionFullName_in_textVar810);
            	    fm=functionFullName();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_functionFullName.add(fm.getTree());
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:42: ( '=' StringLiteral )?
            	    int alt12=2;
            	    int LA12_0 = input.LA(1);

            	    if ( (LA12_0==105) ) {
            	        alt12=1;
            	    }
            	    switch (alt12) {
            	        case 1 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:43: '=' StringLiteral
            	            {
            	            char_literal65=(Token)match(input,105,FOLLOW_105_in_textVar813); if (state.failed) return retval; 
            	            if ( state.backtracking==0 ) stream_105.add(char_literal65);

            	            StringLiteral66=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_textVar815); if (state.failed) return retval; 
            	            if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral66);


            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);



            // AST REWRITE
            // elements: StringLiteral, fm, b
            // token labels: 
            // rule labels: retval, fm, b
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_fm=new RewriteRuleSubtreeStream(adaptor,"rule fm",fm!=null?fm.tree:null);
            RewriteRuleSubtreeStream stream_b=new RewriteRuleSubtreeStream(adaptor,"rule b",b!=null?b.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 187:65: -> ^( VAR_TEXT $b ( ^( FM $fm ( StringLiteral )? ) )* )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:68: ^( VAR_TEXT $b ( ^( FM $fm ( StringLiteral )? ) )* )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(VAR_TEXT, "VAR_TEXT"), root_1);

                adaptor.addChild(root_1, stream_b.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:82: ( ^( FM $fm ( StringLiteral )? ) )*
                while ( stream_fm.hasNext() ) {
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:83: ^( FM $fm ( StringLiteral )? )
                    {
                    BeeCommonNodeTree root_2 = (BeeCommonNodeTree)adaptor.nil();
                    root_2 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(FM, "FM"), root_2);

                    adaptor.addChild(root_2, stream_fm.nextTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:187:92: ( StringLiteral )?
                    if ( stream_StringLiteral.hasNext() ) {
                        adaptor.addChild(root_2, stream_StringLiteral.nextNode());

                    }
                    stream_StringLiteral.reset();

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_fm.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 15, textVar_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "textVar"

    public static class varDefine_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "varDefine"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:189:1: varDefine : a= VAR varAssignMent ( ',' varAssignMent )* -> ( ^( VAR_DEFINE[$a] varAssignMent ) )+ ;
    public final BeeParser.varDefine_return varDefine() throws RecognitionException {
        BeeParser.varDefine_return retval = new BeeParser.varDefine_return();
        retval.start = input.LT(1);
        int varDefine_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal68=null;
        BeeParser.varAssignMent_return varAssignMent67 = null;

        BeeParser.varAssignMent_return varAssignMent69 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal68_tree=null;
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_VAR=new RewriteRuleTokenStream(adaptor,"token VAR");
        RewriteRuleSubtreeStream stream_varAssignMent=new RewriteRuleSubtreeStream(adaptor,"rule varAssignMent");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:191:2: (a= VAR varAssignMent ( ',' varAssignMent )* -> ( ^( VAR_DEFINE[$a] varAssignMent ) )+ )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:191:4: a= VAR varAssignMent ( ',' varAssignMent )*
            {
            a=(Token)match(input,VAR,FOLLOW_VAR_in_varDefine857); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_VAR.add(a);

            if ( state.backtracking==0 ) {
              if(isStrictMVC)	throw new MVCStrictException(a);
            }
            pushFollow(FOLLOW_varAssignMent_in_varDefine860);
            varAssignMent67=varAssignMent();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_varAssignMent.add(varAssignMent67.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:191:75: ( ',' varAssignMent )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( (LA14_0==97) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:191:76: ',' varAssignMent
            	    {
            	    char_literal68=(Token)match(input,97,FOLLOW_97_in_varDefine863); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_97.add(char_literal68);

            	    pushFollow(FOLLOW_varAssignMent_in_varDefine865);
            	    varAssignMent69=varAssignMent();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_varAssignMent.add(varAssignMent69.getTree());

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);



            // AST REWRITE
            // elements: varAssignMent
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 191:96: -> ( ^( VAR_DEFINE[$a] varAssignMent ) )+
            {
                if ( !(stream_varAssignMent.hasNext()) ) {
                    throw new RewriteEarlyExitException();
                }
                while ( stream_varAssignMent.hasNext() ) {
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:191:98: ^( VAR_DEFINE[$a] varAssignMent )
                    {
                    BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                    root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(VAR_DEFINE, a), root_1);

                    adaptor.addChild(root_1, stream_varAssignMent.nextTree());

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_varAssignMent.reset();

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 16, varDefine_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "varDefine"

    public static class varAssignMent_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "varAssignMent"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:194:1: varAssignMent : (a= Identifier -> ^( ASSIGNMENT[$a] Identifier NULL ) | Identifier '=' exp -> ^( ASSIGNMENT[$Identifier] Identifier exp ) );
    public final BeeParser.varAssignMent_return varAssignMent() throws RecognitionException {
        BeeParser.varAssignMent_return retval = new BeeParser.varAssignMent_return();
        retval.start = input.LT(1);
        int varAssignMent_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token Identifier70=null;
        Token char_literal71=null;
        BeeParser.exp_return exp72 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree Identifier70_tree=null;
        BeeCommonNodeTree char_literal71_tree=null;
        RewriteRuleTokenStream stream_105=new RewriteRuleTokenStream(adaptor,"token 105");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:195:2: (a= Identifier -> ^( ASSIGNMENT[$a] Identifier NULL ) | Identifier '=' exp -> ^( ASSIGNMENT[$Identifier] Identifier exp ) )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==Identifier) ) {
                int LA15_1 = input.LA(2);

                if ( (LA15_1==105) ) {
                    alt15=2;
                }
                else if ( (LA15_1==EOF||LA15_1==92||LA15_1==97) ) {
                    alt15=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:195:4: a= Identifier
                    {
                    a=(Token)match(input,Identifier,FOLLOW_Identifier_in_varAssignMent893); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(a);



                    // AST REWRITE
                    // elements: Identifier
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 195:19: -> ^( ASSIGNMENT[$a] Identifier NULL )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:195:22: ^( ASSIGNMENT[$a] Identifier NULL )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(ASSIGNMENT, a), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());
                        adaptor.addChild(root_1, (BeeCommonNodeTree)adaptor.create(NULL, "NULL"));

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:196:4: Identifier '=' exp
                    {
                    Identifier70=(Token)match(input,Identifier,FOLLOW_Identifier_in_varAssignMent914); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier70);

                    char_literal71=(Token)match(input,105,FOLLOW_105_in_varAssignMent916); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_105.add(char_literal71);

                    pushFollow(FOLLOW_exp_in_varAssignMent918);
                    exp72=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_exp.add(exp72.getTree());


                    // AST REWRITE
                    // elements: Identifier, exp
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 196:23: -> ^( ASSIGNMENT[$Identifier] Identifier exp )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:196:26: ^( ASSIGNMENT[$Identifier] Identifier exp )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(ASSIGNMENT, Identifier70), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());
                        adaptor.addChild(root_1, stream_exp.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 17, varAssignMent_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "varAssignMent"

    public static class assignMent_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "assignMent"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:198:1: assignMent : Identifier '=' exp -> ^( ASSIGNMENT[$Identifier] Identifier exp ) ;
    public final BeeParser.assignMent_return assignMent() throws RecognitionException {
        BeeParser.assignMent_return retval = new BeeParser.assignMent_return();
        retval.start = input.LT(1);
        int assignMent_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token Identifier73=null;
        Token char_literal74=null;
        BeeParser.exp_return exp75 = null;


        BeeCommonNodeTree Identifier73_tree=null;
        BeeCommonNodeTree char_literal74_tree=null;
        RewriteRuleTokenStream stream_105=new RewriteRuleTokenStream(adaptor,"token 105");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:199:2: ( Identifier '=' exp -> ^( ASSIGNMENT[$Identifier] Identifier exp ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:199:4: Identifier '=' exp
            {
            Identifier73=(Token)match(input,Identifier,FOLLOW_Identifier_in_assignMent940); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(Identifier73);

            char_literal74=(Token)match(input,105,FOLLOW_105_in_assignMent942); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_105.add(char_literal74);

            pushFollow(FOLLOW_exp_in_assignMent945);
            exp75=exp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_exp.add(exp75.getTree());


            // AST REWRITE
            // elements: Identifier, exp
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 199:25: -> ^( ASSIGNMENT[$Identifier] Identifier exp )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:199:28: ^( ASSIGNMENT[$Identifier] Identifier exp )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(ASSIGNMENT, Identifier73), root_1);

                adaptor.addChild(root_1, stream_Identifier.nextNode());
                adaptor.addChild(root_1, stream_exp.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 18, assignMent_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "assignMent"

    public static class varRef_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "varRef"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:1: varRef : ({...}? Identifier -> ^( TEXT_VAR_REFER[$Identifier] Identifier ) | Identifier ( varAttribute )* ( '!' StringLiteral )? -> ^( VAR_REFER[$Identifier] Identifier ( varAttribute )* ( StringLiteral )? ) );
    public final BeeParser.varRef_return varRef() throws RecognitionException {
        BeeParser.varRef_return retval = new BeeParser.varRef_return();
        retval.start = input.LT(1);
        int varRef_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token Identifier76=null;
        Token Identifier77=null;
        Token char_literal79=null;
        Token StringLiteral80=null;
        BeeParser.varAttribute_return varAttribute78 = null;


        BeeCommonNodeTree Identifier76_tree=null;
        BeeCommonNodeTree Identifier77_tree=null;
        BeeCommonNodeTree char_literal79_tree=null;
        BeeCommonNodeTree StringLiteral80_tree=null;
        RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleTokenStream stream_101=new RewriteRuleTokenStream(adaptor,"token 101");
        RewriteRuleSubtreeStream stream_varAttribute=new RewriteRuleSubtreeStream(adaptor,"rule varAttribute");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:8: ({...}? Identifier -> ^( TEXT_VAR_REFER[$Identifier] Identifier ) | Identifier ( varAttribute )* ( '!' StringLiteral )? -> ^( VAR_REFER[$Identifier] Identifier ( varAttribute )* ( StringLiteral )? ) )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==Identifier) ) {
                int LA18_1 = input.LA(2);

                if ( ((synpred26_Bee()&&(input.LT(1).getText().startsWith("__V")))) ) {
                    alt18=1;
                }
                else if ( (true) ) {
                    alt18=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 18, 1, input);

                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:10: {...}? Identifier
                    {
                    if ( !((input.LT(1).getText().startsWith("__V"))) ) {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        throw new FailedPredicateException(input, "varRef", "input.LT(1).getText().startsWith(\"__V\")");
                    }
                    Identifier76=(Token)match(input,Identifier,FOLLOW_Identifier_in_varRef968); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier76);



                    // AST REWRITE
                    // elements: Identifier
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 201:66: -> ^( TEXT_VAR_REFER[$Identifier] Identifier )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:69: ^( TEXT_VAR_REFER[$Identifier] Identifier )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(TEXT_VAR_REFER, Identifier76), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:4: Identifier ( varAttribute )* ( '!' StringLiteral )?
                    {
                    Identifier77=(Token)match(input,Identifier,FOLLOW_Identifier_in_varRef985); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier77);

                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:15: ( varAttribute )*
                    loop16:
                    do {
                        int alt16=2;
                        int LA16_0 = input.LA(1);

                        if ( ((LA16_0>=106 && LA16_0<=108)) ) {
                            alt16=1;
                        }


                        switch (alt16) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:17: varAttribute
                    	    {
                    	    pushFollow(FOLLOW_varAttribute_in_varRef989);
                    	    varAttribute78=varAttribute();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_varAttribute.add(varAttribute78.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop16;
                        }
                    } while (true);

                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:32: ( '!' StringLiteral )?
                    int alt17=2;
                    int LA17_0 = input.LA(1);

                    if ( (LA17_0==101) ) {
                        int LA17_1 = input.LA(2);

                        if ( (LA17_1==StringLiteral) ) {
                            alt17=1;
                        }
                    }
                    switch (alt17) {
                        case 1 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:33: '!' StringLiteral
                            {
                            char_literal79=(Token)match(input,101,FOLLOW_101_in_varRef994); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_101.add(char_literal79);

                            StringLiteral80=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_varRef996); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral80);


                            }
                            break;

                    }



                    // AST REWRITE
                    // elements: varAttribute, StringLiteral, Identifier
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 202:55: -> ^( VAR_REFER[$Identifier] Identifier ( varAttribute )* ( StringLiteral )? )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:58: ^( VAR_REFER[$Identifier] Identifier ( varAttribute )* ( StringLiteral )? )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(VAR_REFER, Identifier77), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:94: ( varAttribute )*
                        while ( stream_varAttribute.hasNext() ) {
                            adaptor.addChild(root_1, stream_varAttribute.nextTree());

                        }
                        stream_varAttribute.reset();
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:202:110: ( StringLiteral )?
                        if ( stream_StringLiteral.hasNext() ) {
                            adaptor.addChild(root_1, stream_StringLiteral.nextNode());

                        }
                        stream_StringLiteral.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 19, varRef_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "varRef"

    public static class varAttribute_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "varAttribute"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:203:1: varAttribute : ( '.' Identifier -> ^( ATTR_NAME Identifier ) | '.~' Identifier -> ^( VIRTUAL_ATTR_NAME Identifier ) | a= '[' exp ']' -> ^( MAP_LIST_INDEX[$a,\"[]\"] exp ) );
    public final BeeParser.varAttribute_return varAttribute() throws RecognitionException {
        BeeParser.varAttribute_return retval = new BeeParser.varAttribute_return();
        retval.start = input.LT(1);
        int varAttribute_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal81=null;
        Token Identifier82=null;
        Token string_literal83=null;
        Token Identifier84=null;
        Token char_literal86=null;
        BeeParser.exp_return exp85 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal81_tree=null;
        BeeCommonNodeTree Identifier82_tree=null;
        BeeCommonNodeTree string_literal83_tree=null;
        BeeCommonNodeTree Identifier84_tree=null;
        BeeCommonNodeTree char_literal86_tree=null;
        RewriteRuleTokenStream stream_109=new RewriteRuleTokenStream(adaptor,"token 109");
        RewriteRuleTokenStream stream_108=new RewriteRuleTokenStream(adaptor,"token 108");
        RewriteRuleTokenStream stream_107=new RewriteRuleTokenStream(adaptor,"token 107");
        RewriteRuleTokenStream stream_106=new RewriteRuleTokenStream(adaptor,"token 106");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:204:2: ( '.' Identifier -> ^( ATTR_NAME Identifier ) | '.~' Identifier -> ^( VIRTUAL_ATTR_NAME Identifier ) | a= '[' exp ']' -> ^( MAP_LIST_INDEX[$a,\"[]\"] exp ) )
            int alt19=3;
            switch ( input.LA(1) ) {
            case 106:
                {
                alt19=1;
                }
                break;
            case 107:
                {
                alt19=2;
                }
                break;
            case 108:
                {
                alt19=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;
            }

            switch (alt19) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:204:4: '.' Identifier
                    {
                    char_literal81=(Token)match(input,106,FOLLOW_106_in_varAttribute1025); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_106.add(char_literal81);

                    Identifier82=(Token)match(input,Identifier,FOLLOW_Identifier_in_varAttribute1027); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier82);



                    // AST REWRITE
                    // elements: Identifier
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 204:19: -> ^( ATTR_NAME Identifier )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:204:22: ^( ATTR_NAME Identifier )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(ATTR_NAME, "ATTR_NAME"), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:205:4: '.~' Identifier
                    {
                    string_literal83=(Token)match(input,107,FOLLOW_107_in_varAttribute1041); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_107.add(string_literal83);

                    Identifier84=(Token)match(input,Identifier,FOLLOW_Identifier_in_varAttribute1043); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier84);



                    // AST REWRITE
                    // elements: Identifier
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 205:21: -> ^( VIRTUAL_ATTR_NAME Identifier )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:205:24: ^( VIRTUAL_ATTR_NAME Identifier )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(VIRTUAL_ATTR_NAME, "VIRTUAL_ATTR_NAME"), root_1);

                        adaptor.addChild(root_1, stream_Identifier.nextNode());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 3 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:206:4: a= '[' exp ']'
                    {
                    a=(Token)match(input,108,FOLLOW_108_in_varAttribute1060); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_108.add(a);

                    pushFollow(FOLLOW_exp_in_varAttribute1062);
                    exp85=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_exp.add(exp85.getTree());
                    char_literal86=(Token)match(input,109,FOLLOW_109_in_varAttribute1064); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_109.add(char_literal86);



                    // AST REWRITE
                    // elements: exp
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 206:18: -> ^( MAP_LIST_INDEX[$a,\"[]\"] exp )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:206:20: ^( MAP_LIST_INDEX[$a,\"[]\"] exp )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(MAP_LIST_INDEX, a, "[]"), root_1);

                        adaptor.addChild(root_1, stream_exp.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 20, varAttribute_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "varAttribute"

    public static class exp_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "exp"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:209:1: exp : condExp ;
    public final BeeParser.exp_return exp() throws RecognitionException {
        BeeParser.exp_return retval = new BeeParser.exp_return();
        retval.start = input.LT(1);
        int exp_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        BeeParser.condExp_return condExp87 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:209:5: ( condExp )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:209:8: condExp
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_condExp_in_exp1085);
            condExp87=condExp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, condExp87.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 21, exp_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "exp"

    public static class condExp_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condExp"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:212:1: condExp : conditionalOrExpression ;
    public final BeeParser.condExp_return condExp() throws RecognitionException {
        BeeParser.condExp_return retval = new BeeParser.condExp_return();
        retval.start = input.LT(1);
        int condExp_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        BeeParser.conditionalOrExpression_return conditionalOrExpression88 = null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:212:9: ( conditionalOrExpression )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:212:11: conditionalOrExpression
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_conditionalOrExpression_in_condExp1096);
            conditionalOrExpression88=conditionalOrExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalOrExpression88.getTree());

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 22, condExp_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "condExp"

    public static class conditionalOrExpression_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalOrExpression"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:214:1: conditionalOrExpression : conditionalAndExpression ( OR conditionalAndExpression )* ;
    public final BeeParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
        BeeParser.conditionalOrExpression_return retval = new BeeParser.conditionalOrExpression_return();
        retval.start = input.LT(1);
        int conditionalOrExpression_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token OR90=null;
        BeeParser.conditionalAndExpression_return conditionalAndExpression89 = null;

        BeeParser.conditionalAndExpression_return conditionalAndExpression91 = null;


        BeeCommonNodeTree OR90_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:215:5: ( conditionalAndExpression ( OR conditionalAndExpression )* )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:215:9: conditionalAndExpression ( OR conditionalAndExpression )*
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression1114);
            conditionalAndExpression89=conditionalAndExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalAndExpression89.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:216:9: ( OR conditionalAndExpression )*
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( (LA20_0==OR) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:216:10: OR conditionalAndExpression
            	    {
            	    OR90=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression1125); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    OR90_tree = (BeeCommonNodeTree)adaptor.create(OR90);
            	    root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(OR90_tree, root_0);
            	    }
            	    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression1128);
            	    conditionalAndExpression91=conditionalAndExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalAndExpression91.getTree());

            	    }
            	    break;

            	default :
            	    break loop20;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 23, conditionalOrExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalOrExpression"

    public static class conditionalAndExpression_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "conditionalAndExpression"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:220:1: conditionalAndExpression : condExpNotItem ( AND condExpNotItem )* ;
    public final BeeParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
        BeeParser.conditionalAndExpression_return retval = new BeeParser.conditionalAndExpression_return();
        retval.start = input.LT(1);
        int conditionalAndExpression_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token AND93=null;
        BeeParser.condExpNotItem_return condExpNotItem92 = null;

        BeeParser.condExpNotItem_return condExpNotItem94 = null;


        BeeCommonNodeTree AND93_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:221:5: ( condExpNotItem ( AND condExpNotItem )* )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:221:9: condExpNotItem ( AND condExpNotItem )*
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_condExpNotItem_in_conditionalAndExpression1159);
            condExpNotItem92=condExpNotItem();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, condExpNotItem92.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:222:9: ( AND condExpNotItem )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==AND) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:222:10: AND condExpNotItem
            	    {
            	    AND93=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression1170); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    AND93_tree = (BeeCommonNodeTree)adaptor.create(AND93);
            	    root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(AND93_tree, root_0);
            	    }
            	    pushFollow(FOLLOW_condExpNotItem_in_conditionalAndExpression1173);
            	    condExpNotItem94=condExpNotItem();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, condExpNotItem94.getTree());

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 24, conditionalAndExpression_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "conditionalAndExpression"

    public static class condExpNotItem_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condExpNotItem"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:225:1: condExpNotItem : ( condExpItem -> condExpItem | ( '!' ) condExpItem -> ^( NOT condExpItem ) );
    public final BeeParser.condExpNotItem_return condExpNotItem() throws RecognitionException {
        BeeParser.condExpNotItem_return retval = new BeeParser.condExpNotItem_return();
        retval.start = input.LT(1);
        int condExpNotItem_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token char_literal96=null;
        BeeParser.condExpItem_return condExpItem95 = null;

        BeeParser.condExpItem_return condExpItem97 = null;


        BeeCommonNodeTree char_literal96_tree=null;
        RewriteRuleTokenStream stream_101=new RewriteRuleTokenStream(adaptor,"token 101");
        RewriteRuleSubtreeStream stream_condExpItem=new RewriteRuleSubtreeStream(adaptor,"rule condExpItem");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:226:2: ( condExpItem -> condExpItem | ( '!' ) condExpItem -> ^( NOT condExpItem ) )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==LEFT_BRACE||LA22_0==Identifier||LA22_0==StringLiteral||(LA22_0>=ADD && LA22_0<=MINUS)||(LA22_0>=BOOLEAN && LA22_0<=DOUBLE)||LA22_0==96||LA22_0==108||LA22_0==110) ) {
                alt22=1;
            }
            else if ( (LA22_0==101) ) {
                alt22=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:226:4: condExpItem
                    {
                    pushFollow(FOLLOW_condExpItem_in_condExpNotItem1198);
                    condExpItem95=condExpItem();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_condExpItem.add(condExpItem95.getTree());


                    // AST REWRITE
                    // elements: condExpItem
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 226:16: -> condExpItem
                    {
                        adaptor.addChild(root_0, stream_condExpItem.nextTree());

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:227:4: ( '!' ) condExpItem
                    {
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:227:4: ( '!' )
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:227:5: '!'
                    {
                    char_literal96=(Token)match(input,101,FOLLOW_101_in_condExpNotItem1207); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_101.add(char_literal96);


                    }

                    pushFollow(FOLLOW_condExpItem_in_condExpNotItem1210);
                    condExpItem97=condExpItem();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_condExpItem.add(condExpItem97.getTree());


                    // AST REWRITE
                    // elements: condExpItem
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 227:22: -> ^( NOT condExpItem )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:227:25: ^( NOT condExpItem )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(NOT, "NOT"), root_1);

                        adaptor.addChild(root_1, stream_condExpItem.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 25, condExpNotItem_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "condExpNotItem"

    public static class condExpItem_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "condExpItem"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:228:1: condExpItem : aexpr ( (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL ) l= aexpr )? ;
    public final BeeParser.condExpItem_return condExpItem() throws RecognitionException {
        BeeParser.condExpItem_return retval = new BeeParser.condExpItem_return();
        retval.start = input.LT(1);
        int condExpItem_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        BeeParser.aexpr_return l = null;

        BeeParser.aexpr_return aexpr98 = null;


        BeeCommonNodeTree a_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:2: ( aexpr ( (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL ) l= aexpr )? )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:6: aexpr ( (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL ) l= aexpr )?
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_aexpr_in_condExpItem1229);
            aexpr98=aexpr();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, aexpr98.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:12: ( (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL ) l= aexpr )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( ((LA24_0>=EQUAL && LA24_0<=LESS_EQUAL)) ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:14: (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL ) l= aexpr
                    {
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:14: (a= EQUAL | a= NOT_EQUAL | a= LARGE | a= LARGE_EQUAL | a= LESS | a= LESS_EQUAL )
                    int alt23=6;
                    switch ( input.LA(1) ) {
                    case EQUAL:
                        {
                        alt23=1;
                        }
                        break;
                    case NOT_EQUAL:
                        {
                        alt23=2;
                        }
                        break;
                    case LARGE:
                        {
                        alt23=3;
                        }
                        break;
                    case LARGE_EQUAL:
                        {
                        alt23=4;
                        }
                        break;
                    case LESS:
                        {
                        alt23=5;
                        }
                        break;
                    case LESS_EQUAL:
                        {
                        alt23=6;
                        }
                        break;
                    default:
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 23, 0, input);

                        throw nvae;
                    }

                    switch (alt23) {
                        case 1 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:15: a= EQUAL
                            {
                            a=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_condExpItem1236); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;
                        case 2 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:24: a= NOT_EQUAL
                            {
                            a=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_condExpItem1241); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;
                        case 3 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:37: a= LARGE
                            {
                            a=(Token)match(input,LARGE,FOLLOW_LARGE_in_condExpItem1246); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;
                        case 4 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:46: a= LARGE_EQUAL
                            {
                            a=(Token)match(input,LARGE_EQUAL,FOLLOW_LARGE_EQUAL_in_condExpItem1251); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;
                        case 5 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:61: a= LESS
                            {
                            a=(Token)match(input,LESS,FOLLOW_LESS_in_condExpItem1256); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;
                        case 6 :
                            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:229:69: a= LESS_EQUAL
                            {
                            a=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_condExpItem1261); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            a_tree = (BeeCommonNodeTree)adaptor.create(a);
                            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
                            }

                            }
                            break;

                    }

                    if ( state.backtracking==0 ) {
                      if(isStrictMVC)	throw new MVCStrictException(a);
                    }
                    pushFollow(FOLLOW_aexpr_in_condExpItem1268);
                    l=aexpr();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, l.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 26, condExpItem_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "condExpItem"

    public static class aexpr_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "aexpr"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:1: aexpr : mexpr ( (a= ADD | a= MINUS ) mexpr )* ;
    public final BeeParser.aexpr_return aexpr() throws RecognitionException {
        BeeParser.aexpr_return retval = new BeeParser.aexpr_return();
        retval.start = input.LT(1);
        int aexpr_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        BeeParser.mexpr_return mexpr99 = null;

        BeeParser.mexpr_return mexpr100 = null;


        BeeCommonNodeTree a_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:7: ( mexpr ( (a= ADD | a= MINUS ) mexpr )* )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:9: mexpr ( (a= ADD | a= MINUS ) mexpr )*
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_mexpr_in_aexpr1278);
            mexpr99=mexpr();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, mexpr99.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:15: ( (a= ADD | a= MINUS ) mexpr )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( ((LA26_0>=ADD && LA26_0<=MINUS)) ) {
                    alt26=1;
                }


                switch (alt26) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:16: (a= ADD | a= MINUS ) mexpr
            	    {
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:16: (a= ADD | a= MINUS )
            	    int alt25=2;
            	    int LA25_0 = input.LA(1);

            	    if ( (LA25_0==ADD) ) {
            	        alt25=1;
            	    }
            	    else if ( (LA25_0==MINUS) ) {
            	        alt25=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 25, 0, input);

            	        throw nvae;
            	    }
            	    switch (alt25) {
            	        case 1 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:17: a= ADD
            	            {
            	            a=(Token)match(input,ADD,FOLLOW_ADD_in_aexpr1284); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            a_tree = (BeeCommonNodeTree)adaptor.create(a);
            	            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:230:24: a= MINUS
            	            {
            	            a=(Token)match(input,MINUS,FOLLOW_MINUS_in_aexpr1289); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            a_tree = (BeeCommonNodeTree)adaptor.create(a);
            	            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
            	            }

            	            }
            	            break;

            	    }

            	    pushFollow(FOLLOW_mexpr_in_aexpr1293);
            	    mexpr100=mexpr();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, mexpr100.getTree());
            	    if ( state.backtracking==0 ) {
            	      if(isStrictMVC)	throw new MVCStrictException(a);
            	    }

            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 27, aexpr_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "aexpr"

    public static class mexpr_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "mexpr"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:1: mexpr : unaryAtom ( (a= MULTIP | a= DIV | a= MOD ) unaryAtom )* ;
    public final BeeParser.mexpr_return mexpr() throws RecognitionException {
        BeeParser.mexpr_return retval = new BeeParser.mexpr_return();
        retval.start = input.LT(1);
        int mexpr_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        BeeParser.unaryAtom_return unaryAtom101 = null;

        BeeParser.unaryAtom_return unaryAtom102 = null;


        BeeCommonNodeTree a_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:9: ( unaryAtom ( (a= MULTIP | a= DIV | a= MOD ) unaryAtom )* )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:17: unaryAtom ( (a= MULTIP | a= DIV | a= MOD ) unaryAtom )*
            {
            root_0 = (BeeCommonNodeTree)adaptor.nil();

            pushFollow(FOLLOW_unaryAtom_in_mexpr1313);
            unaryAtom101=unaryAtom();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryAtom101.getTree());
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:27: ( (a= MULTIP | a= DIV | a= MOD ) unaryAtom )*
            loop28:
            do {
                int alt28=2;
                int LA28_0 = input.LA(1);

                if ( ((LA28_0>=MULTIP && LA28_0<=MOD)) ) {
                    alt28=1;
                }


                switch (alt28) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:28: (a= MULTIP | a= DIV | a= MOD ) unaryAtom
            	    {
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:28: (a= MULTIP | a= DIV | a= MOD )
            	    int alt27=3;
            	    switch ( input.LA(1) ) {
            	    case MULTIP:
            	        {
            	        alt27=1;
            	        }
            	        break;
            	    case DIV:
            	        {
            	        alt27=2;
            	        }
            	        break;
            	    case MOD:
            	        {
            	        alt27=3;
            	        }
            	        break;
            	    default:
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 27, 0, input);

            	        throw nvae;
            	    }

            	    switch (alt27) {
            	        case 1 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:29: a= MULTIP
            	            {
            	            a=(Token)match(input,MULTIP,FOLLOW_MULTIP_in_mexpr1319); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            a_tree = (BeeCommonNodeTree)adaptor.create(a);
            	            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 2 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:39: a= DIV
            	            {
            	            a=(Token)match(input,DIV,FOLLOW_DIV_in_mexpr1324); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            a_tree = (BeeCommonNodeTree)adaptor.create(a);
            	            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
            	            }

            	            }
            	            break;
            	        case 3 :
            	            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:231:46: a= MOD
            	            {
            	            a=(Token)match(input,MOD,FOLLOW_MOD_in_mexpr1329); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            a_tree = (BeeCommonNodeTree)adaptor.create(a);
            	            root_0 = (BeeCommonNodeTree)adaptor.becomeRoot(a_tree, root_0);
            	            }

            	            }
            	            break;

            	    }

            	    if ( state.backtracking==0 ) {
            	      if(isStrictMVC)	throw new MVCStrictException(a);
            	    }
            	    pushFollow(FOLLOW_unaryAtom_in_mexpr1334);
            	    unaryAtom102=unaryAtom();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryAtom102.getTree());

            	    }
            	    break;

            	default :
            	    break loop28;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 28, mexpr_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "mexpr"

    public static class atom_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "atom"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:232:1: atom : ( BOOLEAN | INT | NULL | DOUBLE | a= StringLiteral -> | varRef | '(' exp ')' | functionCall[false] | nativeMethod[false] | json );
    public final BeeParser.atom_return atom() throws RecognitionException {
        BeeParser.atom_return retval = new BeeParser.atom_return();
        retval.start = input.LT(1);
        int atom_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token BOOLEAN103=null;
        Token INT104=null;
        Token NULL105=null;
        Token DOUBLE106=null;
        Token char_literal108=null;
        Token char_literal110=null;
        BeeParser.varRef_return varRef107 = null;

        BeeParser.exp_return exp109 = null;

        BeeParser.functionCall_return functionCall111 = null;

        BeeParser.nativeMethod_return nativeMethod112 = null;

        BeeParser.json_return json113 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree BOOLEAN103_tree=null;
        BeeCommonNodeTree INT104_tree=null;
        BeeCommonNodeTree NULL105_tree=null;
        BeeCommonNodeTree DOUBLE106_tree=null;
        BeeCommonNodeTree char_literal108_tree=null;
        BeeCommonNodeTree char_literal110_tree=null;
        RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:232:6: ( BOOLEAN | INT | NULL | DOUBLE | a= StringLiteral -> | varRef | '(' exp ')' | functionCall[false] | nativeMethod[false] | json )
            int alt29=10;
            alt29 = dfa29.predict(input);
            switch (alt29) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:232:8: BOOLEAN
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    BOOLEAN103=(Token)match(input,BOOLEAN,FOLLOW_BOOLEAN_in_atom1343); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    BOOLEAN103_tree = (BeeCommonNodeTree)adaptor.create(BOOLEAN103);
                    adaptor.addChild(root_0, BOOLEAN103_tree);
                    }

                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:234:6: INT
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    INT104=(Token)match(input,INT,FOLLOW_INT_in_atom1352); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    INT104_tree = (BeeCommonNodeTree)adaptor.create(INT104);
                    adaptor.addChild(root_0, INT104_tree);
                    }

                    }
                    break;
                case 3 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:235:4: NULL
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    NULL105=(Token)match(input,NULL,FOLLOW_NULL_in_atom1357); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    NULL105_tree = (BeeCommonNodeTree)adaptor.create(NULL105);
                    adaptor.addChild(root_0, NULL105_tree);
                    }

                    }
                    break;
                case 4 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:236:4: DOUBLE
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    DOUBLE106=(Token)match(input,DOUBLE,FOLLOW_DOUBLE_in_atom1362); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    DOUBLE106_tree = (BeeCommonNodeTree)adaptor.create(DOUBLE106);
                    adaptor.addChild(root_0, DOUBLE106_tree);
                    }

                    }
                    break;
                case 5 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:237:4: a= StringLiteral
                    {
                    a=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_atom1369); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_StringLiteral.add(a);



                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 237:20: ->
                    {
                        adaptor.addChild(root_0, new BeeCommonNodeTree(new CommonToken(StringLiteral,BeetlUtil.getEscapeString((a!=null?a.getText():null)))));

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 6 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:238:4: varRef
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_varRef_in_atom1378);
                    varRef107=varRef();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, varRef107.getTree());

                    }
                    break;
                case 7 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:239:4: '(' exp ')'
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    char_literal108=(Token)match(input,96,FOLLOW_96_in_atom1384); if (state.failed) return retval;
                    pushFollow(FOLLOW_exp_in_atom1387);
                    exp109=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, exp109.getTree());
                    char_literal110=(Token)match(input,98,FOLLOW_98_in_atom1389); if (state.failed) return retval;

                    }
                    break;
                case 8 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:240:4: functionCall[false]
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_functionCall_in_atom1396);
                    functionCall111=functionCall(false);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, functionCall111.getTree());

                    }
                    break;
                case 9 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:241:4: nativeMethod[false]
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_nativeMethod_in_atom1402);
                    nativeMethod112=nativeMethod(false);

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nativeMethod112.getTree());

                    }
                    break;
                case 10 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:242:4: json
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_json_in_atom1408);
                    json113=json();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, json113.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 29, atom_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "atom"

    public static class unaryAtom_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "unaryAtom"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:244:1: unaryAtom : ( atom | MINUS a= atom -> ^( NEGATOM atom ) | ADD atom -> atom );
    public final BeeParser.unaryAtom_return unaryAtom() throws RecognitionException {
        BeeParser.unaryAtom_return retval = new BeeParser.unaryAtom_return();
        retval.start = input.LT(1);
        int unaryAtom_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token MINUS115=null;
        Token ADD116=null;
        BeeParser.atom_return a = null;

        BeeParser.atom_return atom114 = null;

        BeeParser.atom_return atom117 = null;


        BeeCommonNodeTree MINUS115_tree=null;
        BeeCommonNodeTree ADD116_tree=null;
        RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
        RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
        RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:245:2: ( atom | MINUS a= atom -> ^( NEGATOM atom ) | ADD atom -> atom )
            int alt30=3;
            switch ( input.LA(1) ) {
            case LEFT_BRACE:
            case Identifier:
            case StringLiteral:
            case BOOLEAN:
            case INT:
            case NULL:
            case DOUBLE:
            case 96:
            case 108:
            case 110:
                {
                alt30=1;
                }
                break;
            case MINUS:
                {
                alt30=2;
                }
                break;
            case ADD:
                {
                alt30=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }

            switch (alt30) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:245:4: atom
                    {
                    root_0 = (BeeCommonNodeTree)adaptor.nil();

                    pushFollow(FOLLOW_atom_in_unaryAtom1419);
                    atom114=atom();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, atom114.getTree());

                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:246:4: MINUS a= atom
                    {
                    MINUS115=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryAtom1425); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_MINUS.add(MINUS115);

                    pushFollow(FOLLOW_atom_in_unaryAtom1429);
                    a=atom();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_atom.add(a.getTree());


                    // AST REWRITE
                    // elements: atom
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 246:17: -> ^( NEGATOM atom )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:246:19: ^( NEGATOM atom )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(NEGATOM, "NEGATOM"), root_1);

                        adaptor.addChild(root_1, stream_atom.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 3 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:247:4: ADD atom
                    {
                    ADD116=(Token)match(input,ADD,FOLLOW_ADD_in_unaryAtom1441); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_ADD.add(ADD116);

                    pushFollow(FOLLOW_atom_in_unaryAtom1443);
                    atom117=atom();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_atom.add(atom117.getTree());


                    // AST REWRITE
                    // elements: atom
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 247:13: -> atom
                    {
                        adaptor.addChild(root_0, stream_atom.nextTree());

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 30, unaryAtom_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "unaryAtom"

    public static class nativeMethod_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "nativeMethod"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:1: nativeMethod[boolean statmentCall] : a= '@' Identifier ( '.' Identifier )* ( '.' classMethod )? -> {statmentCall}? ^( DIRECT_CALL ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) ) -> ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) ;
    public final BeeParser.nativeMethod_return nativeMethod(boolean statmentCall) throws RecognitionException {
        BeeParser.nativeMethod_return retval = new BeeParser.nativeMethod_return();
        retval.start = input.LT(1);
        int nativeMethod_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token Identifier118=null;
        Token char_literal119=null;
        Token Identifier120=null;
        Token char_literal121=null;
        BeeParser.classMethod_return classMethod122 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree Identifier118_tree=null;
        BeeCommonNodeTree char_literal119_tree=null;
        BeeCommonNodeTree Identifier120_tree=null;
        BeeCommonNodeTree char_literal121_tree=null;
        RewriteRuleTokenStream stream_110=new RewriteRuleTokenStream(adaptor,"token 110");
        RewriteRuleTokenStream stream_106=new RewriteRuleTokenStream(adaptor,"token 106");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleSubtreeStream stream_classMethod=new RewriteRuleSubtreeStream(adaptor,"rule classMethod");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:37: (a= '@' Identifier ( '.' Identifier )* ( '.' classMethod )? -> {statmentCall}? ^( DIRECT_CALL ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) ) -> ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:38: a= '@' Identifier ( '.' Identifier )* ( '.' classMethod )?
            {
            a=(Token)match(input,110,FOLLOW_110_in_nativeMethod1460); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_110.add(a);

            Identifier118=(Token)match(input,Identifier,FOLLOW_Identifier_in_nativeMethod1462); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(Identifier118);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:55: ( '.' Identifier )*
            loop31:
            do {
                int alt31=2;
                int LA31_0 = input.LA(1);

                if ( (LA31_0==106) ) {
                    int LA31_1 = input.LA(2);

                    if ( (LA31_1==Identifier) ) {
                        int LA31_3 = input.LA(3);

                        if ( (LA31_3==EOF||LA31_3==RIGHT_BRACE||LA31_3==RIGHT_TOKEN||(LA31_3>=OR && LA31_3<=MOD)||LA31_3==92||(LA31_3>=97 && LA31_3<=98)||LA31_3==106||LA31_3==109||LA31_3==113) ) {
                            alt31=1;
                        }


                    }


                }


                switch (alt31) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:56: '.' Identifier
            	    {
            	    char_literal119=(Token)match(input,106,FOLLOW_106_in_nativeMethod1465); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_106.add(char_literal119);

            	    Identifier120=(Token)match(input,Identifier,FOLLOW_Identifier_in_nativeMethod1467); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_Identifier.add(Identifier120);


            	    }
            	    break;

            	default :
            	    break loop31;
                }
            } while (true);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:73: ( '.' classMethod )?
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( (LA32_0==106) ) {
                alt32=1;
            }
            switch (alt32) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:249:74: '.' classMethod
                    {
                    char_literal121=(Token)match(input,106,FOLLOW_106_in_nativeMethod1472); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_106.add(char_literal121);

                    pushFollow(FOLLOW_classMethod_in_nativeMethod1474);
                    classMethod122=classMethod();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_classMethod.add(classMethod122.getTree());

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
              if(!openBackdoor) throw new MVCStrictException(a);
            }


            // AST REWRITE
            // elements: classMethod, Identifier, Identifier, classMethod
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 250:4: -> {statmentCall}? ^( DIRECT_CALL ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) )
            if (statmentCall) {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:250:25: ^( DIRECT_CALL ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? ) )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(DIRECT_CALL, "DIRECT_CALL"), root_1);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:250:39: ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? )
                {
                BeeCommonNodeTree root_2 = (BeeCommonNodeTree)adaptor.nil();
                root_2 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(CLASS_FUNCTION, a), root_2);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:250:60: ( Identifier )*
                while ( stream_Identifier.hasNext() ) {
                    adaptor.addChild(root_2, stream_Identifier.nextNode());

                }
                stream_Identifier.reset();
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:250:72: ( classMethod )?
                if ( stream_classMethod.hasNext() ) {
                    adaptor.addChild(root_2, stream_classMethod.nextTree());

                }
                stream_classMethod.reset();

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }
            else // 251:4: -> ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:251:7: ^( CLASS_FUNCTION[$a] ( Identifier )* ( classMethod )? )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(CLASS_FUNCTION, a), root_1);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:251:28: ( Identifier )*
                while ( stream_Identifier.hasNext() ) {
                    adaptor.addChild(root_1, stream_Identifier.nextNode());

                }
                stream_Identifier.reset();
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:251:40: ( classMethod )?
                if ( stream_classMethod.hasNext() ) {
                    adaptor.addChild(root_1, stream_classMethod.nextTree());

                }
                stream_classMethod.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 31, nativeMethod_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "nativeMethod"

    public static class classMethod_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "classMethod"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:254:1: classMethod : Identifier '(' ( exp ( ',' exp )* )? ')' -> ^( CLASS_METHOD[$Identifier] Identifier ( exp )* ) ;
    public final BeeParser.classMethod_return classMethod() throws RecognitionException {
        BeeParser.classMethod_return retval = new BeeParser.classMethod_return();
        retval.start = input.LT(1);
        int classMethod_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token Identifier123=null;
        Token char_literal124=null;
        Token char_literal126=null;
        Token char_literal128=null;
        BeeParser.exp_return exp125 = null;

        BeeParser.exp_return exp127 = null;


        BeeCommonNodeTree Identifier123_tree=null;
        BeeCommonNodeTree char_literal124_tree=null;
        BeeCommonNodeTree char_literal126_tree=null;
        BeeCommonNodeTree char_literal128_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:2: ( Identifier '(' ( exp ( ',' exp )* )? ')' -> ^( CLASS_METHOD[$Identifier] Identifier ( exp )* ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:4: Identifier '(' ( exp ( ',' exp )* )? ')'
            {
            Identifier123=(Token)match(input,Identifier,FOLLOW_Identifier_in_classMethod1539); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(Identifier123);

            char_literal124=(Token)match(input,96,FOLLOW_96_in_classMethod1541); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(char_literal124);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:19: ( exp ( ',' exp )* )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==LEFT_BRACE||LA34_0==Identifier||LA34_0==StringLiteral||(LA34_0>=ADD && LA34_0<=MINUS)||(LA34_0>=BOOLEAN && LA34_0<=DOUBLE)||LA34_0==96||LA34_0==101||LA34_0==108||LA34_0==110) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:20: exp ( ',' exp )*
                    {
                    pushFollow(FOLLOW_exp_in_classMethod1544);
                    exp125=exp();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_exp.add(exp125.getTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:24: ( ',' exp )*
                    loop33:
                    do {
                        int alt33=2;
                        int LA33_0 = input.LA(1);

                        if ( (LA33_0==97) ) {
                            alt33=1;
                        }


                        switch (alt33) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:25: ',' exp
                    	    {
                    	    char_literal126=(Token)match(input,97,FOLLOW_97_in_classMethod1547); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_97.add(char_literal126);

                    	    pushFollow(FOLLOW_exp_in_classMethod1549);
                    	    exp127=exp();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_exp.add(exp127.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop33;
                        }
                    } while (true);


                    }
                    break;

            }

            char_literal128=(Token)match(input,98,FOLLOW_98_in_classMethod1555); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal128);



            // AST REWRITE
            // elements: exp, Identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 255:41: -> ^( CLASS_METHOD[$Identifier] Identifier ( exp )* )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:43: ^( CLASS_METHOD[$Identifier] Identifier ( exp )* )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(CLASS_METHOD, Identifier123), root_1);

                adaptor.addChild(root_1, stream_Identifier.nextNode());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:255:82: ( exp )*
                while ( stream_exp.hasNext() ) {
                    adaptor.addChild(root_1, stream_exp.nextTree());

                }
                stream_exp.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 32, classMethod_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "classMethod"

    public static class functionFullName_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "functionFullName"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:1: functionFullName : a= Identifier ( '.' Identifier )? -> ^( FUNCTION_FULL_NAME[$a] ( Identifier )* ) ;
    public final BeeParser.functionFullName_return functionFullName() throws RecognitionException {
        BeeParser.functionFullName_return retval = new BeeParser.functionFullName_return();
        retval.start = input.LT(1);
        int functionFullName_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal129=null;
        Token Identifier130=null;

        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal129_tree=null;
        BeeCommonNodeTree Identifier130_tree=null;
        RewriteRuleTokenStream stream_106=new RewriteRuleTokenStream(adaptor,"token 106");
        RewriteRuleTokenStream stream_Identifier=new RewriteRuleTokenStream(adaptor,"token Identifier");

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:18: (a= Identifier ( '.' Identifier )? -> ^( FUNCTION_FULL_NAME[$a] ( Identifier )* ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:19: a= Identifier ( '.' Identifier )?
            {
            a=(Token)match(input,Identifier,FOLLOW_Identifier_in_functionFullName1577); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_Identifier.add(a);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:32: ( '.' Identifier )?
            int alt35=2;
            int LA35_0 = input.LA(1);

            if ( (LA35_0==106) ) {
                alt35=1;
            }
            switch (alt35) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:33: '.' Identifier
                    {
                    char_literal129=(Token)match(input,106,FOLLOW_106_in_functionFullName1580); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_106.add(char_literal129);

                    Identifier130=(Token)match(input,Identifier,FOLLOW_Identifier_in_functionFullName1582); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_Identifier.add(Identifier130);


                    }
                    break;

            }



            // AST REWRITE
            // elements: Identifier
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 257:51: -> ^( FUNCTION_FULL_NAME[$a] ( Identifier )* )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:54: ^( FUNCTION_FULL_NAME[$a] ( Identifier )* )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(FUNCTION_FULL_NAME, a), root_1);

                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:257:80: ( Identifier )*
                while ( stream_Identifier.hasNext() ) {
                    adaptor.addChild(root_1, stream_Identifier.nextNode());

                }
                stream_Identifier.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 33, functionFullName_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "functionFullName"

    public static class switchStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "switchStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:259:1: switchStatment : a= 'switch' '(' base= exp ')' '{' ( caseStatment )* ( defaultStatment )? '}' -> ^( SWITCH[$a] $base ( caseStatment )* ( defaultStatment )? ) ;
    public final BeeParser.switchStatment_return switchStatment() throws RecognitionException {
        BeeParser.switchStatment_return retval = new BeeParser.switchStatment_return();
        retval.start = input.LT(1);
        int switchStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal131=null;
        Token char_literal132=null;
        Token char_literal133=null;
        Token char_literal136=null;
        BeeParser.exp_return base = null;

        BeeParser.caseStatment_return caseStatment134 = null;

        BeeParser.defaultStatment_return defaultStatment135 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal131_tree=null;
        BeeCommonNodeTree char_literal132_tree=null;
        BeeCommonNodeTree char_literal133_tree=null;
        BeeCommonNodeTree char_literal136_tree=null;
        RewriteRuleTokenStream stream_98=new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_RIGHT_BRACE=new RewriteRuleTokenStream(adaptor,"token RIGHT_BRACE");
        RewriteRuleTokenStream stream_96=new RewriteRuleTokenStream(adaptor,"token 96");
        RewriteRuleTokenStream stream_111=new RewriteRuleTokenStream(adaptor,"token 111");
        RewriteRuleTokenStream stream_LEFT_BRACE=new RewriteRuleTokenStream(adaptor,"token LEFT_BRACE");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        RewriteRuleSubtreeStream stream_caseStatment=new RewriteRuleSubtreeStream(adaptor,"rule caseStatment");
        RewriteRuleSubtreeStream stream_defaultStatment=new RewriteRuleSubtreeStream(adaptor,"rule defaultStatment");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:260:2: (a= 'switch' '(' base= exp ')' '{' ( caseStatment )* ( defaultStatment )? '}' -> ^( SWITCH[$a] $base ( caseStatment )* ( defaultStatment )? ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:260:4: a= 'switch' '(' base= exp ')' '{' ( caseStatment )* ( defaultStatment )? '}'
            {
            a=(Token)match(input,111,FOLLOW_111_in_switchStatment1607); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_111.add(a);

            char_literal131=(Token)match(input,96,FOLLOW_96_in_switchStatment1609); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_96.add(char_literal131);

            pushFollow(FOLLOW_exp_in_switchStatment1613);
            base=exp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_exp.add(base.getTree());
            char_literal132=(Token)match(input,98,FOLLOW_98_in_switchStatment1615); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_98.add(char_literal132);

            char_literal133=(Token)match(input,LEFT_BRACE,FOLLOW_LEFT_BRACE_in_switchStatment1617); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LEFT_BRACE.add(char_literal133);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:260:36: ( caseStatment )*
            loop36:
            do {
                int alt36=2;
                int LA36_0 = input.LA(1);

                if ( (LA36_0==112) ) {
                    alt36=1;
                }


                switch (alt36) {
            	case 1 :
            	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:0:0: caseStatment
            	    {
            	    pushFollow(FOLLOW_caseStatment_in_switchStatment1619);
            	    caseStatment134=caseStatment();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_caseStatment.add(caseStatment134.getTree());

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } while (true);

            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:260:50: ( defaultStatment )?
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==114) ) {
                alt37=1;
            }
            switch (alt37) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:0:0: defaultStatment
                    {
                    pushFollow(FOLLOW_defaultStatment_in_switchStatment1622);
                    defaultStatment135=defaultStatment();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_defaultStatment.add(defaultStatment135.getTree());

                    }
                    break;

            }

            char_literal136=(Token)match(input,RIGHT_BRACE,FOLLOW_RIGHT_BRACE_in_switchStatment1625); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RIGHT_BRACE.add(char_literal136);



            // AST REWRITE
            // elements: base, defaultStatment, caseStatment
            // token labels: 
            // rule labels: retval, base
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
            RewriteRuleSubtreeStream stream_base=new RewriteRuleSubtreeStream(adaptor,"rule base",base!=null?base.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 261:3: -> ^( SWITCH[$a] $base ( caseStatment )* ( defaultStatment )? )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:261:5: ^( SWITCH[$a] $base ( caseStatment )* ( defaultStatment )? )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(SWITCH, a), root_1);

                adaptor.addChild(root_1, stream_base.nextTree());
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:261:24: ( caseStatment )*
                while ( stream_caseStatment.hasNext() ) {
                    adaptor.addChild(root_1, stream_caseStatment.nextTree());

                }
                stream_caseStatment.reset();
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:261:38: ( defaultStatment )?
                if ( stream_defaultStatment.hasNext() ) {
                    adaptor.addChild(root_1, stream_defaultStatment.nextTree());

                }
                stream_defaultStatment.reset();

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 34, switchStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "switchStatment"

    public static class caseStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "caseStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:262:1: caseStatment : a= 'case' exp ':' statements -> ^( CASE[$a] exp statements ) ;
    public final BeeParser.caseStatment_return caseStatment() throws RecognitionException {
        BeeParser.caseStatment_return retval = new BeeParser.caseStatment_return();
        retval.start = input.LT(1);
        int caseStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal138=null;
        BeeParser.exp_return exp137 = null;

        BeeParser.statements_return statements139 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal138_tree=null;
        RewriteRuleTokenStream stream_112=new RewriteRuleTokenStream(adaptor,"token 112");
        RewriteRuleTokenStream stream_113=new RewriteRuleTokenStream(adaptor,"token 113");
        RewriteRuleSubtreeStream stream_exp=new RewriteRuleSubtreeStream(adaptor,"rule exp");
        RewriteRuleSubtreeStream stream_statements=new RewriteRuleSubtreeStream(adaptor,"rule statements");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:263:2: (a= 'case' exp ':' statements -> ^( CASE[$a] exp statements ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:263:4: a= 'case' exp ':' statements
            {
            a=(Token)match(input,112,FOLLOW_112_in_caseStatment1654); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_112.add(a);

            pushFollow(FOLLOW_exp_in_caseStatment1656);
            exp137=exp();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_exp.add(exp137.getTree());
            char_literal138=(Token)match(input,113,FOLLOW_113_in_caseStatment1658); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_113.add(char_literal138);

            pushFollow(FOLLOW_statements_in_caseStatment1660);
            statements139=statements();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_statements.add(statements139.getTree());


            // AST REWRITE
            // elements: statements, exp
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 263:32: -> ^( CASE[$a] exp statements )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:263:34: ^( CASE[$a] exp statements )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(CASE, a), root_1);

                adaptor.addChild(root_1, stream_exp.nextTree());
                adaptor.addChild(root_1, stream_statements.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 35, caseStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "caseStatment"

    public static class defaultStatment_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "defaultStatment"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:264:1: defaultStatment : a= 'default' ':' statements -> ^( DEFAULT[$a] statements ) ;
    public final BeeParser.defaultStatment_return defaultStatment() throws RecognitionException {
        BeeParser.defaultStatment_return retval = new BeeParser.defaultStatment_return();
        retval.start = input.LT(1);
        int defaultStatment_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token a=null;
        Token char_literal140=null;
        BeeParser.statements_return statements141 = null;


        BeeCommonNodeTree a_tree=null;
        BeeCommonNodeTree char_literal140_tree=null;
        RewriteRuleTokenStream stream_114=new RewriteRuleTokenStream(adaptor,"token 114");
        RewriteRuleTokenStream stream_113=new RewriteRuleTokenStream(adaptor,"token 113");
        RewriteRuleSubtreeStream stream_statements=new RewriteRuleSubtreeStream(adaptor,"rule statements");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:265:2: (a= 'default' ':' statements -> ^( DEFAULT[$a] statements ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:265:4: a= 'default' ':' statements
            {
            a=(Token)match(input,114,FOLLOW_114_in_defaultStatment1680); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_114.add(a);

            char_literal140=(Token)match(input,113,FOLLOW_113_in_defaultStatment1682); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_113.add(char_literal140);

            pushFollow(FOLLOW_statements_in_defaultStatment1684);
            statements141=statements();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_statements.add(statements141.getTree());


            // AST REWRITE
            // elements: statements
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 265:31: -> ^( DEFAULT[$a] statements )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:265:34: ^( DEFAULT[$a] statements )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(DEFAULT, a), root_1);

                adaptor.addChild(root_1, stream_statements.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 36, defaultStatment_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "defaultStatment"

    public static class json_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "json"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:1: json : ( '[' atom ( ',' atom )* ']' -> ^( JSONARRAY ( atom )* ) | '{' jsonKeyValue ( ',' jsonKeyValue )* '}' -> ^( JSONMAP ( jsonKeyValue )* ) );
    public final BeeParser.json_return json() throws RecognitionException {
        BeeParser.json_return retval = new BeeParser.json_return();
        retval.start = input.LT(1);
        int json_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token char_literal142=null;
        Token char_literal144=null;
        Token char_literal146=null;
        Token char_literal147=null;
        Token char_literal149=null;
        Token char_literal151=null;
        BeeParser.atom_return atom143 = null;

        BeeParser.atom_return atom145 = null;

        BeeParser.jsonKeyValue_return jsonKeyValue148 = null;

        BeeParser.jsonKeyValue_return jsonKeyValue150 = null;


        BeeCommonNodeTree char_literal142_tree=null;
        BeeCommonNodeTree char_literal144_tree=null;
        BeeCommonNodeTree char_literal146_tree=null;
        BeeCommonNodeTree char_literal147_tree=null;
        BeeCommonNodeTree char_literal149_tree=null;
        BeeCommonNodeTree char_literal151_tree=null;
        RewriteRuleTokenStream stream_RIGHT_BRACE=new RewriteRuleTokenStream(adaptor,"token RIGHT_BRACE");
        RewriteRuleTokenStream stream_97=new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_109=new RewriteRuleTokenStream(adaptor,"token 109");
        RewriteRuleTokenStream stream_108=new RewriteRuleTokenStream(adaptor,"token 108");
        RewriteRuleTokenStream stream_LEFT_BRACE=new RewriteRuleTokenStream(adaptor,"token LEFT_BRACE");
        RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom");
        RewriteRuleSubtreeStream stream_jsonKeyValue=new RewriteRuleSubtreeStream(adaptor,"rule jsonKeyValue");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:6: ( '[' atom ( ',' atom )* ']' -> ^( JSONARRAY ( atom )* ) | '{' jsonKeyValue ( ',' jsonKeyValue )* '}' -> ^( JSONMAP ( jsonKeyValue )* ) )
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==108) ) {
                alt40=1;
            }
            else if ( (LA40_0==LEFT_BRACE) ) {
                alt40=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 40, 0, input);

                throw nvae;
            }
            switch (alt40) {
                case 1 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:8: '[' atom ( ',' atom )* ']'
                    {
                    char_literal142=(Token)match(input,108,FOLLOW_108_in_json1700); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_108.add(char_literal142);

                    pushFollow(FOLLOW_atom_in_json1702);
                    atom143=atom();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_atom.add(atom143.getTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:18: ( ',' atom )*
                    loop38:
                    do {
                        int alt38=2;
                        int LA38_0 = input.LA(1);

                        if ( (LA38_0==97) ) {
                            alt38=1;
                        }


                        switch (alt38) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:19: ',' atom
                    	    {
                    	    char_literal144=(Token)match(input,97,FOLLOW_97_in_json1706); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_97.add(char_literal144);

                    	    pushFollow(FOLLOW_atom_in_json1708);
                    	    atom145=atom();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_atom.add(atom145.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop38;
                        }
                    } while (true);

                    char_literal146=(Token)match(input,109,FOLLOW_109_in_json1712); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_109.add(char_literal146);



                    // AST REWRITE
                    // elements: atom
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 266:34: -> ^( JSONARRAY ( atom )* )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:36: ^( JSONARRAY ( atom )* )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(JSONARRAY, "JSONARRAY"), root_1);

                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:266:48: ( atom )*
                        while ( stream_atom.hasNext() ) {
                            adaptor.addChild(root_1, stream_atom.nextTree());

                        }
                        stream_atom.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;
                case 2 :
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:267:4: '{' jsonKeyValue ( ',' jsonKeyValue )* '}'
                    {
                    char_literal147=(Token)match(input,LEFT_BRACE,FOLLOW_LEFT_BRACE_in_json1725); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LEFT_BRACE.add(char_literal147);

                    pushFollow(FOLLOW_jsonKeyValue_in_json1727);
                    jsonKeyValue148=jsonKeyValue();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_jsonKeyValue.add(jsonKeyValue148.getTree());
                    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:267:21: ( ',' jsonKeyValue )*
                    loop39:
                    do {
                        int alt39=2;
                        int LA39_0 = input.LA(1);

                        if ( (LA39_0==97) ) {
                            alt39=1;
                        }


                        switch (alt39) {
                    	case 1 :
                    	    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:267:22: ',' jsonKeyValue
                    	    {
                    	    char_literal149=(Token)match(input,97,FOLLOW_97_in_json1730); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_97.add(char_literal149);

                    	    pushFollow(FOLLOW_jsonKeyValue_in_json1732);
                    	    jsonKeyValue150=jsonKeyValue();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_jsonKeyValue.add(jsonKeyValue150.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop39;
                        }
                    } while (true);

                    char_literal151=(Token)match(input,RIGHT_BRACE,FOLLOW_RIGHT_BRACE_in_json1736); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_RIGHT_BRACE.add(char_literal151);



                    // AST REWRITE
                    // elements: jsonKeyValue
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (BeeCommonNodeTree)adaptor.nil();
                    // 267:45: -> ^( JSONMAP ( jsonKeyValue )* )
                    {
                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:267:47: ^( JSONMAP ( jsonKeyValue )* )
                        {
                        BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                        root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(JSONMAP, "JSONMAP"), root_1);

                        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:267:57: ( jsonKeyValue )*
                        while ( stream_jsonKeyValue.hasNext() ) {
                            adaptor.addChild(root_1, stream_jsonKeyValue.nextTree());

                        }
                        stream_jsonKeyValue.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }

                    retval.tree = root_0;}
                    }
                    break;

            }
            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 37, json_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "json"

    public static class jsonKeyValue_return extends ParserRuleReturnScope {
        BeeCommonNodeTree tree;
        public Object getTree() { return tree; }
    };

    // $ANTLR start "jsonKeyValue"
    // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:269:1: jsonKeyValue : StringLiteral ':' atom -> ^( JSONKEYVALUE StringLiteral atom ) ;
    public final BeeParser.jsonKeyValue_return jsonKeyValue() throws RecognitionException {
        BeeParser.jsonKeyValue_return retval = new BeeParser.jsonKeyValue_return();
        retval.start = input.LT(1);
        int jsonKeyValue_StartIndex = input.index();
        BeeCommonNodeTree root_0 = null;

        Token StringLiteral152=null;
        Token char_literal153=null;
        BeeParser.atom_return atom154 = null;


        BeeCommonNodeTree StringLiteral152_tree=null;
        BeeCommonNodeTree char_literal153_tree=null;
        RewriteRuleTokenStream stream_StringLiteral=new RewriteRuleTokenStream(adaptor,"token StringLiteral");
        RewriteRuleTokenStream stream_113=new RewriteRuleTokenStream(adaptor,"token 113");
        RewriteRuleSubtreeStream stream_atom=new RewriteRuleSubtreeStream(adaptor,"rule atom");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return retval; }
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:270:2: ( StringLiteral ':' atom -> ^( JSONKEYVALUE StringLiteral atom ) )
            // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:270:4: StringLiteral ':' atom
            {
            StringLiteral152=(Token)match(input,StringLiteral,FOLLOW_StringLiteral_in_jsonKeyValue1754); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_StringLiteral.add(StringLiteral152);

            char_literal153=(Token)match(input,113,FOLLOW_113_in_jsonKeyValue1756); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_113.add(char_literal153);

            pushFollow(FOLLOW_atom_in_jsonKeyValue1758);
            atom154=atom();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_atom.add(atom154.getTree());


            // AST REWRITE
            // elements: StringLiteral, atom
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (BeeCommonNodeTree)adaptor.nil();
            // 270:27: -> ^( JSONKEYVALUE StringLiteral atom )
            {
                // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:270:29: ^( JSONKEYVALUE StringLiteral atom )
                {
                BeeCommonNodeTree root_1 = (BeeCommonNodeTree)adaptor.nil();
                root_1 = (BeeCommonNodeTree)adaptor.becomeRoot((BeeCommonNodeTree)adaptor.create(JSONKEYVALUE, "JSONKEYVALUE"), root_1);

                adaptor.addChild(root_1, stream_StringLiteral.nextNode());
                adaptor.addChild(root_1, stream_atom.nextTree());

                adaptor.addChild(root_0, root_1);
                }

            }

            retval.tree = root_0;}
            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (BeeCommonNodeTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }

        catch (RecognitionException e) {
        reportError(e); 
        throw e;
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 38, jsonKeyValue_StartIndex); }
        }
        return retval;
    }
    // $ANTLR end "jsonKeyValue"

    // $ANTLR start synpred20_Bee
    public final void synpred20_Bee_fragment() throws RecognitionException {   
        BeeParser.statement_return n = null;


        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:38: ( 'else' n= statement )
        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:178:38: 'else' n= statement
        {
        match(input,103,FOLLOW_103_in_synpred20_Bee691); if (state.failed) return ;
        pushFollow(FOLLOW_statement_in_synpred20_Bee695);
        n=statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred20_Bee

    // $ANTLR start synpred26_Bee
    public final void synpred26_Bee_fragment() throws RecognitionException {   
        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:10: ({...}? Identifier )
        // e:\\lijz\\javamonkey\\bee\\trunk\\workspace\\beetl1.2.m1\\src\\org\\bee\\tl\\core\\Bee.g:201:10: {...}? Identifier
        {
        if ( !((input.LT(1).getText().startsWith("__V"))) ) {
            if (state.backtracking>0) {state.failed=true; return ;}
            throw new FailedPredicateException(input, "synpred26_Bee", "input.LT(1).getText().startsWith(\"__V\")");
        }
        match(input,Identifier,FOLLOW_Identifier_in_synpred26_Bee968); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred26_Bee

    // Delegated rules

    public final boolean synpred26_Bee() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred26_Bee_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred20_Bee() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred20_Bee_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA2 dfa2 = new DFA2(this);
    protected DFA29 dfa29 = new DFA29(this);
    static final String DFA2_eotS =
        "\17\uffff";
    static final String DFA2_eofS =
        "\17\uffff";
    static final String DFA2_minS =
        "\1\52\2\uffff\1\140\13\uffff";
    static final String DFA2_maxS =
        "\1\157\2\uffff\1\152\13\uffff";
    static final String DFA2_acceptS =
        "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\6\1\7\1\11\1\12\1\13\1\14\1"+
        "\15\1\3\1\10";
    static final String DFA2_specialS =
        "\17\uffff}>";
    static final String[] DFA2_transitionS = {
            "\1\7\1\uffff\1\3\1\1\1\uffff\1\4\1\uffff\1\2\53\uffff\1\12"+
            "\1\10\1\11\3\uffff\1\6\2\uffff\1\5\7\uffff\1\14\1\13",
            "",
            "",
            "\1\16\10\uffff\1\15\1\16",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
    static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
    static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
    static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
    static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
    static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
    static final short[][] DFA2_transition;

    static {
        int numStates = DFA2_transitionS.length;
        DFA2_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
        }
    }

    class DFA2 extends DFA {

        public DFA2(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 2;
            this.eot = DFA2_eot;
            this.eof = DFA2_eof;
            this.min = DFA2_min;
            this.max = DFA2_max;
            this.accept = DFA2_accept;
            this.special = DFA2_special;
            this.transition = DFA2_transition;
        }
        public String getDescription() {
            return "126:1: statement : ( constantsTextStatment | varDefine ';' | assignMent ';' | textStatment | ifStatment | forStatment | statmentBlock | messFunction | continueStatment ';' | breakStatment ';' | returnStatment ';' | switchStatment | nativeMethod[true] ';' );";
        }
    }
    static final String DFA29_eotS =
        "\16\uffff";
    static final String DFA29_eofS =
        "\6\uffff\1\12\6\uffff\1\12";
    static final String DFA29_minS =
        "\1\52\5\uffff\1\53\4\uffff\1\54\1\uffff\1\53";
    static final String DFA29_maxS =
        "\1\156\5\uffff\1\161\4\uffff\1\54\1\uffff\1\161";
    static final String DFA29_acceptS =
        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\uffff\1\7\1\11\1\12\1\6\1\uffff"+
        "\1\10\1\uffff";
    static final String DFA29_specialS =
        "\16\uffff}>";
    static final String[] DFA29_transitionS = {
            "\1\11\1\uffff\1\6\3\uffff\1\5\16\uffff\1\1\1\2\1\3\1\4\35\uffff"+
            "\1\7\13\uffff\1\11\1\uffff\1\10",
            "",
            "",
            "",
            "",
            "",
            "\1\12\2\uffff\1\12\3\uffff\15\12\35\uffff\1\12\3\uffff\1\14"+
            "\2\12\2\uffff\1\12\4\uffff\1\13\3\12\3\uffff\1\12",
            "",
            "",
            "",
            "",
            "\1\15",
            "",
            "\1\12\2\uffff\1\12\3\uffff\15\12\35\uffff\1\12\3\uffff\1\14"+
            "\2\12\2\uffff\1\12\4\uffff\4\12\3\uffff\1\12"
    };

    static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
    static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
    static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
    static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
    static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
    static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
    static final short[][] DFA29_transition;

    static {
        int numStates = DFA29_transitionS.length;
        DFA29_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA29_transition[i] = DFA.unpackEncodedString(DFA29_transitionS[i]);
        }
    }

    class DFA29 extends DFA {

        public DFA29(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 29;
            this.eot = DFA29_eot;
            this.eof = DFA29_eof;
            this.min = DFA29_min;
            this.max = DFA29_max;
            this.accept = DFA29_accept;
            this.special = DFA29_special;
            this.transition = DFA29_transition;
        }
        public String getDescription() {
            return "232:1: atom : ( BOOLEAN | INT | NULL | DOUBLE | a= StringLiteral -> | varRef | '(' exp ')' | functionCall[false] | nativeMethod[false] | json );";
        }
    }
 

    public static final BitSet FOLLOW_statements_in_prog285 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_prog287 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statements295 = new BitSet(new long[]{0x0002B40000000002L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_constantsTextStatment_in_statement304 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_varDefine_in_statement311 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement313 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignMent_in_statement319 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement321 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_textStatment_in_statement327 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatment_in_statement332 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStatment_in_statement337 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statmentBlock_in_statement342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_messFunction_in_statement347 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_continueStatment_in_statement352 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement354 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_breakStatment_in_statement360 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStatment_in_statement368 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement370 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchStatment_in_statement376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nativeMethod_in_statement381 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_statement384 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_93_in_returnStatment401 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_94_in_continueStatment414 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_95_in_breakStatment428 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_textProcessFunction_in_messFunction455 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionCall_in_messFunction462 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L});
    public static final BitSet FOLLOW_92_in_messFunction465 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionFullName_in_textProcessFunction476 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_textProcessFunction480 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D06DE0000007L});
    public static final BitSet FOLLOW_exp_in_textProcessFunction483 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_97_in_textProcessFunction486 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_textProcessFunction488 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_98_in_textProcessFunction494 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_statmentBlock_in_textProcessFunction496 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionFullName_in_functionCall531 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_functionCall535 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D06DE0000007L});
    public static final BitSet FOLLOW_exp_in_functionCall538 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_97_in_functionCall541 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_functionCall543 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_98_in_functionCall549 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEFT_BRACE_in_statmentBlock598 = new BitSet(new long[]{0x0002BC0000000000L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_statements_in_statmentBlock600 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RIGHT_BRACE_in_statmentBlock603 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_99_in_forStatment620 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_forStatment622 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_forStatment626 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L});
    public static final BitSet FOLLOW_100_in_forStatment628 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_varRef_in_forStatment632 = new BitSet(new long[]{0x0000000000000000L,0x0000002400000000L});
    public static final BitSet FOLLOW_101_in_forStatment637 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_forStatment641 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_statmentBlock_in_forStatment646 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_102_in_ifStatment678 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_ifStatment680 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_condExp_in_ifStatment682 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_ifStatment684 = new BitSet(new long[]{0x0002B40000000000L,0x0000C0C8E0000000L});
    public static final BitSet FOLLOW_statement_in_ifStatment688 = new BitSet(new long[]{0x0000000000000002L,0x0000008000000000L});
    public static final BitSet FOLLOW_103_in_ifStatment691 = new BitSet(new long[]{0x0002B40000000000L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_statement_in_ifStatment695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEFT_TEXT_TOKEN_in_constantsTextStatment725 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_constantsTextStatment728 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_RIGHT_TOKEN_in_constantsTextStatment730 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEFT_TOKEN_in_textStatment760 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_textVar_in_textStatment762 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_RIGHT_TOKEN_in_textStatment764 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEFT_TOKEN_in_textStatment777 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L});
    public static final BitSet FOLLOW_104_in_textStatment779 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_textVar_in_textStatment781 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_textStatment783 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_RIGHT_TOKEN_in_textStatment784 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exp_in_textVar803 = new BitSet(new long[]{0x0000000000000002L,0x0000000200000000L});
    public static final BitSet FOLLOW_97_in_textVar806 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_functionFullName_in_textVar810 = new BitSet(new long[]{0x0000000000000002L,0x0000020200000000L});
    public static final BitSet FOLLOW_105_in_textVar813 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_StringLiteral_in_textVar815 = new BitSet(new long[]{0x0000000000000002L,0x0000000200000000L});
    public static final BitSet FOLLOW_VAR_in_varDefine857 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_varAssignMent_in_varDefine860 = new BitSet(new long[]{0x0000000000000002L,0x0000000200000000L});
    public static final BitSet FOLLOW_97_in_varDefine863 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_varAssignMent_in_varDefine865 = new BitSet(new long[]{0x0000000000000002L,0x0000000200000000L});
    public static final BitSet FOLLOW_Identifier_in_varAssignMent893 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_varAssignMent914 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_105_in_varAssignMent916 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_varAssignMent918 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_assignMent940 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_105_in_assignMent942 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_assignMent945 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_varRef968 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_varRef985 = new BitSet(new long[]{0x0000000000000002L,0x00001C2000000000L});
    public static final BitSet FOLLOW_varAttribute_in_varRef989 = new BitSet(new long[]{0x0000000000000002L,0x00001C2000000000L});
    public static final BitSet FOLLOW_101_in_varRef994 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_StringLiteral_in_varRef996 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_106_in_varAttribute1025 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_varAttribute1027 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_107_in_varAttribute1041 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_varAttribute1043 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_108_in_varAttribute1060 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_varAttribute1062 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_109_in_varAttribute1064 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_condExp_in_exp1085 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalOrExpression_in_condExp1096 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression1114 = new BitSet(new long[]{0x0004000000000002L});
    public static final BitSet FOLLOW_OR_in_conditionalOrExpression1125 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression1128 = new BitSet(new long[]{0x0004000000000002L});
    public static final BitSet FOLLOW_condExpNotItem_in_conditionalAndExpression1159 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_AND_in_conditionalAndExpression1170 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_condExpNotItem_in_conditionalAndExpression1173 = new BitSet(new long[]{0x0008000000000002L});
    public static final BitSet FOLLOW_condExpItem_in_condExpNotItem1198 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_101_in_condExpNotItem1207 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_condExpItem_in_condExpNotItem1210 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_aexpr_in_condExpItem1229 = new BitSet(new long[]{0x03F0000000000002L});
    public static final BitSet FOLLOW_EQUAL_in_condExpItem1236 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_NOT_EQUAL_in_condExpItem1241 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_LARGE_in_condExpItem1246 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_LARGE_EQUAL_in_condExpItem1251 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_LESS_in_condExpItem1256 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_LESS_EQUAL_in_condExpItem1261 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_aexpr_in_condExpItem1268 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_mexpr_in_aexpr1278 = new BitSet(new long[]{0x0C00000000000002L});
    public static final BitSet FOLLOW_ADD_in_aexpr1284 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_MINUS_in_aexpr1289 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_mexpr_in_aexpr1293 = new BitSet(new long[]{0x0C00000000000002L});
    public static final BitSet FOLLOW_unaryAtom_in_mexpr1313 = new BitSet(new long[]{0x7000000000000002L});
    public static final BitSet FOLLOW_MULTIP_in_mexpr1319 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_DIV_in_mexpr1324 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_MOD_in_mexpr1329 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_unaryAtom_in_mexpr1334 = new BitSet(new long[]{0x7000000000000002L});
    public static final BitSet FOLLOW_BOOLEAN_in_atom1343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_INT_in_atom1352 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NULL_in_atom1357 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOUBLE_in_atom1362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_atom1369 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_varRef_in_atom1378 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_96_in_atom1384 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_atom1387 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_atom1389 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionCall_in_atom1396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nativeMethod_in_atom1402 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_json_in_atom1408 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_atom_in_unaryAtom1419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_MINUS_in_unaryAtom1425 = new BitSet(new long[]{0x8003B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_atom_in_unaryAtom1429 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ADD_in_unaryAtom1441 = new BitSet(new long[]{0x8003B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_atom_in_unaryAtom1443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_110_in_nativeMethod1460 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_nativeMethod1462 = new BitSet(new long[]{0x0000000000000002L,0x0000040000000000L});
    public static final BitSet FOLLOW_106_in_nativeMethod1465 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_nativeMethod1467 = new BitSet(new long[]{0x0000000000000002L,0x0000040000000000L});
    public static final BitSet FOLLOW_106_in_nativeMethod1472 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_classMethod_in_nativeMethod1474 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_classMethod1539 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_classMethod1541 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D06DE0000007L});
    public static final BitSet FOLLOW_exp_in_classMethod1544 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_97_in_classMethod1547 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_classMethod1549 = new BitSet(new long[]{0x0000000000000000L,0x0000000600000000L});
    public static final BitSet FOLLOW_98_in_classMethod1555 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_functionFullName1577 = new BitSet(new long[]{0x0000000000000002L,0x0000040000000000L});
    public static final BitSet FOLLOW_106_in_functionFullName1580 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_Identifier_in_functionFullName1582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_111_in_switchStatment1607 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_switchStatment1609 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_switchStatment1613 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_switchStatment1615 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_LEFT_BRACE_in_switchStatment1617 = new BitSet(new long[]{0x0000080000000000L,0x0005000000000000L});
    public static final BitSet FOLLOW_caseStatment_in_switchStatment1619 = new BitSet(new long[]{0x0000080000000000L,0x0005000000000000L});
    public static final BitSet FOLLOW_defaultStatment_in_switchStatment1622 = new BitSet(new long[]{0x0000080000000000L});
    public static final BitSet FOLLOW_RIGHT_BRACE_in_switchStatment1625 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_112_in_caseStatment1654 = new BitSet(new long[]{0x8C03B40000000000L,0x0000D069E0000007L});
    public static final BitSet FOLLOW_exp_in_caseStatment1656 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
    public static final BitSet FOLLOW_113_in_caseStatment1658 = new BitSet(new long[]{0x0002B40000000000L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_statements_in_caseStatment1660 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_114_in_defaultStatment1680 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
    public static final BitSet FOLLOW_113_in_defaultStatment1682 = new BitSet(new long[]{0x0002B40000000000L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_statements_in_defaultStatment1684 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_108_in_json1700 = new BitSet(new long[]{0x8003B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_atom_in_json1702 = new BitSet(new long[]{0x0000000000000000L,0x0000200200000000L});
    public static final BitSet FOLLOW_97_in_json1706 = new BitSet(new long[]{0x8003B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_atom_in_json1708 = new BitSet(new long[]{0x0000000000000000L,0x0000200200000000L});
    public static final BitSet FOLLOW_109_in_json1712 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LEFT_BRACE_in_json1725 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_jsonKeyValue_in_json1727 = new BitSet(new long[]{0x0000080000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_97_in_json1730 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_jsonKeyValue_in_json1732 = new BitSet(new long[]{0x0000080000000000L,0x0000000200000000L});
    public static final BitSet FOLLOW_RIGHT_BRACE_in_json1736 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_StringLiteral_in_jsonKeyValue1754 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L});
    public static final BitSet FOLLOW_113_in_jsonKeyValue1756 = new BitSet(new long[]{0x8003B40000000000L,0x0000D049E0000007L});
    public static final BitSet FOLLOW_atom_in_jsonKeyValue1758 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_103_in_synpred20_Bee691 = new BitSet(new long[]{0x0002B40000000000L,0x0000C048E0000000L});
    public static final BitSet FOLLOW_statement_in_synpred20_Bee695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_synpred26_Bee968 = new BitSet(new long[]{0x0000000000000002L});

}